]> 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
PR gold/12957
[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:
e9f53129
AM		 610 case EM_XSTORMY16:
611 case EM_XTENSA:
612 case EM_XTENSA_OLD:
7ba29e2a
NC		 613 case EM_MICROBLAZE:
614 case EM_MICROBLAZE_OLD:
9c19a809 615 return TRUE;
103f02d3 616
e9f53129
AM		 617 case EM_68HC05:
618 case EM_68HC08:
619 case EM_68HC11:
620 case EM_68HC16:
621 case EM_FX66:
622 case EM_ME16:
d1133906 623 case EM_MMA:
d1133906
NC		 624 case EM_NCPU:
625 case EM_NDR1:
e9f53129 626 case EM_PCP:
d1133906 627 case EM_ST100:
e9f53129 628 case EM_ST19:
d1133906 629 case EM_ST7:
e9f53129
AM		 630 case EM_ST9PLUS:
631 case EM_STARCORE:
d1133906 632 case EM_SVX:
e9f53129 633 case EM_TINYJ:
9c19a809
NC		 634 default:
635 warn (_("Don't know about relocations on this machine architecture\n"));
636 return FALSE;
637 }
638}
252b5132 639
9c19a809 640static int
2cf0635d 641slurp_rela_relocs (FILE * file,
d3ba0551
AM		 642 unsigned long rel_offset,
643 unsigned long rel_size,
2cf0635d
NC		 644 Elf_Internal_Rela ** relasp,
645 unsigned long * nrelasp)
9c19a809 646{
2cf0635d 647 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 648 unsigned long nrelas;
649 unsigned int i;
252b5132 650
4d6ed7c8
NC		 651 if (is_32bit_elf)
652 {
2cf0635d 653 Elf32_External_Rela * erelas;
103f02d3 654
3f5e193b
NC		 655 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
656 rel_size, _("relocs"));
a6e9f9df
AM		 657 if (!erelas)
658 return 0;
252b5132 659
4d6ed7c8 660 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 661
3f5e193b
NC		 662 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
663 sizeof (Elf_Internal_Rela));
103f02d3 664
4d6ed7c8
NC		 665 if (relas == NULL)
666 {
c256ffe7 667 free (erelas);
591a748a 668 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 669 return 0;
670 }
103f02d3 671
4d6ed7c8
NC		 672 for (i = 0; i < nrelas; i++)
673 {
674 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
675 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 676 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 677 }
103f02d3 678
4d6ed7c8
NC		 679 free (erelas);
680 }
681 else
682 {
2cf0635d 683 Elf64_External_Rela * erelas;
103f02d3 684
3f5e193b
NC		 685 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
686 rel_size, _("relocs"));
a6e9f9df
AM		 687 if (!erelas)
688 return 0;
4d6ed7c8
NC		 689
690 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 691
3f5e193b
NC		 692 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
693 sizeof (Elf_Internal_Rela));
103f02d3 694
4d6ed7c8
NC		 695 if (relas == NULL)
696 {
c256ffe7 697 free (erelas);
591a748a 698 error (_("out of memory parsing relocs\n"));
4d6ed7c8 699 return 0;
9c19a809 700 }
4d6ed7c8
NC		 701
702 for (i = 0; i < nrelas; i++)
9c19a809 703 {
66543521
AM		 704 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
705 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 706 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 707
708 /* The #ifdef BFD64 below is to prevent a compile time
709 warning. We know that if we do not have a 64 bit data
710 type that we will never execute this code anyway. */
711#ifdef BFD64
712 if (elf_header.e_machine == EM_MIPS
713 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
714 {
715 /* In little-endian objects, r_info isn't really a
716 64-bit little-endian value: it has a 32-bit
717 little-endian symbol index followed by four
718 individual byte fields. Reorder INFO
719 accordingly. */
91d6fa6a
NC		 720 bfd_vma inf = relas[i].r_info;
721 inf = (((inf & 0xffffffff) << 32)
722 | ((inf >> 56) & 0xff)
723 | ((inf >> 40) & 0xff00)
724 | ((inf >> 24) & 0xff0000)
725 | ((inf >> 8) & 0xff000000));
726 relas[i].r_info = inf;
861fb55a
DJ		 727 }
728#endif /* BFD64 */
4d6ed7c8 729 }
103f02d3 730
4d6ed7c8
NC		 731 free (erelas);
732 }
733 *relasp = relas;
734 *nrelasp = nrelas;
735 return 1;
736}
103f02d3 737
4d6ed7c8 738static int
2cf0635d 739slurp_rel_relocs (FILE * file,
d3ba0551
AM		 740 unsigned long rel_offset,
741 unsigned long rel_size,
2cf0635d
NC		 742 Elf_Internal_Rela ** relsp,
743 unsigned long * nrelsp)
4d6ed7c8 744{
2cf0635d 745 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 746 unsigned long nrels;
747 unsigned int i;
103f02d3 748
4d6ed7c8
NC		 749 if (is_32bit_elf)
750 {
2cf0635d 751 Elf32_External_Rel * erels;
103f02d3 752
3f5e193b
NC		 753 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
754 rel_size, _("relocs"));
a6e9f9df
AM		 755 if (!erels)
756 return 0;
103f02d3 757
4d6ed7c8 758 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 759
3f5e193b 760 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 761
4d6ed7c8
NC		 762 if (rels == NULL)
763 {
c256ffe7 764 free (erels);
591a748a 765 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 766 return 0;
767 }
768
769 for (i = 0; i < nrels; i++)
770 {
771 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
772 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 773 rels[i].r_addend = 0;
9ea033b2 774 }
4d6ed7c8
NC		 775
776 free (erels);
9c19a809
NC		 777 }
778 else
779 {
2cf0635d 780 Elf64_External_Rel * erels;
9ea033b2 781
3f5e193b
NC		 782 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
783 rel_size, _("relocs"));
a6e9f9df
AM		 784 if (!erels)
785 return 0;
103f02d3 786
4d6ed7c8 787 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 788
3f5e193b 789 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 790
4d6ed7c8 791 if (rels == NULL)
9c19a809 792 {
c256ffe7 793 free (erels);
591a748a 794 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 795 return 0;
796 }
103f02d3 797
4d6ed7c8
NC		 798 for (i = 0; i < nrels; i++)
799 {
66543521
AM		 800 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
801 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 802 rels[i].r_addend = 0;
861fb55a
DJ		 803
804 /* The #ifdef BFD64 below is to prevent a compile time
805 warning. We know that if we do not have a 64 bit data
806 type that we will never execute this code anyway. */
807#ifdef BFD64
808 if (elf_header.e_machine == EM_MIPS
809 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
810 {
811 /* In little-endian objects, r_info isn't really a
812 64-bit little-endian value: it has a 32-bit
813 little-endian symbol index followed by four
814 individual byte fields. Reorder INFO
815 accordingly. */
91d6fa6a
NC		 816 bfd_vma inf = rels[i].r_info;
817 inf = (((inf & 0xffffffff) << 32)
818 | ((inf >> 56) & 0xff)
819 | ((inf >> 40) & 0xff00)
820 | ((inf >> 24) & 0xff0000)
821 | ((inf >> 8) & 0xff000000));
822 rels[i].r_info = inf;
861fb55a
DJ		 823 }
824#endif /* BFD64 */
4d6ed7c8 825 }
103f02d3 826
4d6ed7c8
NC		 827 free (erels);
828 }
829 *relsp = rels;
830 *nrelsp = nrels;
831 return 1;
832}
103f02d3 833
aca88567
NC		 834/* Returns the reloc type extracted from the reloc info field. */
835
836static unsigned int
837get_reloc_type (bfd_vma reloc_info)
838{
839 if (is_32bit_elf)
840 return ELF32_R_TYPE (reloc_info);
841
842 switch (elf_header.e_machine)
843 {
844 case EM_MIPS:
845 /* Note: We assume that reloc_info has already been adjusted for us. */
846 return ELF64_MIPS_R_TYPE (reloc_info);
847
848 case EM_SPARCV9:
849 return ELF64_R_TYPE_ID (reloc_info);
850
851 default:
852 return ELF64_R_TYPE (reloc_info);
853 }
854}
855
856/* Return the symbol index extracted from the reloc info field. */
857
858static bfd_vma
859get_reloc_symindex (bfd_vma reloc_info)
860{
861 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
862}
863
d3ba0551
AM		 864/* Display the contents of the relocation data found at the specified
865 offset. */
ee42cf8c 866
41e92641 867static void
2cf0635d 868dump_relocations (FILE * file,
d3ba0551
AM		 869 unsigned long rel_offset,
870 unsigned long rel_size,
2cf0635d 871 Elf_Internal_Sym * symtab,
d3ba0551 872 unsigned long nsyms,
2cf0635d 873 char * strtab,
d79b3d50 874 unsigned long strtablen,
d3ba0551 875 int is_rela)
4d6ed7c8 876{
b34976b6 877 unsigned int i;
2cf0635d 878 Elf_Internal_Rela * rels;
103f02d3 879
4d6ed7c8
NC		 880 if (is_rela == UNKNOWN)
881 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 882
4d6ed7c8
NC		 883 if (is_rela)
884 {
c8286bd1 885 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 886 return;
4d6ed7c8
NC		 887 }
888 else
889 {
890 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 891 return;
252b5132
RH		 892 }
893
410f7a12
L		 894 if (is_32bit_elf)
895 {
896 if (is_rela)
2c71103e
NC		 897 {
898 if (do_wide)
899 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
900 else
901 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
902 }
410f7a12 903 else
2c71103e
NC		 904 {
905 if (do_wide)
906 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
907 else
908 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
909 }
410f7a12 910 }
252b5132 911 else
410f7a12
L		 912 {
913 if (is_rela)
2c71103e
NC		 914 {
915 if (do_wide)
8beeaeb7 916 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 917 else
918 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
919 }
410f7a12 920 else
2c71103e
NC		 921 {
922 if (do_wide)
8beeaeb7 923 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 924 else
925 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
926 }
410f7a12 927 }
252b5132
RH		 928
929 for (i = 0; i < rel_size; i++)
930 {
2cf0635d 931 const char * rtype;
b34976b6 932 bfd_vma offset;
91d6fa6a 933 bfd_vma inf;
b34976b6
AM		 934 bfd_vma symtab_index;
935 bfd_vma type;
103f02d3 936
b34976b6 937 offset = rels[i].r_offset;
91d6fa6a 938 inf = rels[i].r_info;
103f02d3 939
91d6fa6a
NC		 940 type = get_reloc_type (inf);
941 symtab_index = get_reloc_symindex (inf);
252b5132 942
410f7a12
L		 943 if (is_32bit_elf)
944 {
39dbeff8
AM		 945 printf ("%8.8lx %8.8lx ",
946 (unsigned long) offset & 0xffffffff,
91d6fa6a 947 (unsigned long) inf & 0xffffffff);
410f7a12
L		 948 }
949 else
950 {
39dbeff8
AM		 951#if BFD_HOST_64BIT_LONG
952 printf (do_wide
953 ? "%16.16lx %16.16lx "
954 : "%12.12lx %12.12lx ",
91d6fa6a 955 offset, inf);
39dbeff8 956#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 957#ifndef __MSVCRT__
39dbeff8
AM		 958 printf (do_wide
959 ? "%16.16llx %16.16llx "
960 : "%12.12llx %12.12llx ",
91d6fa6a 961 offset, inf);
6e3d6dc1
NC		 962#else
963 printf (do_wide
964 ? "%16.16I64x %16.16I64x "
965 : "%12.12I64x %12.12I64x ",
91d6fa6a 966 offset, inf);
6e3d6dc1 967#endif
39dbeff8 968#else
2c71103e
NC		 969 printf (do_wide
970 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
971 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 972 _bfd_int64_high (offset),
973 _bfd_int64_low (offset),
91d6fa6a
NC		 974 _bfd_int64_high (inf),
975 _bfd_int64_low (inf));
9ea033b2 976#endif
410f7a12 977 }
103f02d3 978
252b5132
RH		 979 switch (elf_header.e_machine)
980 {
981 default:
982 rtype = NULL;
983 break;
984
2b0337b0 985 case EM_M32R:
252b5132 986 case EM_CYGNUS_M32R:
9ea033b2 987 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 988 break;
989
990 case EM_386:
991 case EM_486:
9ea033b2 992 rtype = elf_i386_reloc_type (type);
252b5132
RH		 993 break;
994
ba2685cc
AM		 995 case EM_68HC11:
996 case EM_68HC12:
997 rtype = elf_m68hc11_reloc_type (type);
998 break;
75751cd9 999
252b5132 1000 case EM_68K:
9ea033b2 1001 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1002 break;
1003
63fcb9e9 1004 case EM_960:
9ea033b2 1005 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1006 break;
1007
adde6300 1008 case EM_AVR:
2b0337b0 1009 case EM_AVR_OLD:
adde6300
AM		 1010 rtype = elf_avr_reloc_type (type);
1011 break;
1012
9ea033b2
NC		 1013 case EM_OLD_SPARCV9:
1014 case EM_SPARC32PLUS:
1015 case EM_SPARCV9:
252b5132 1016 case EM_SPARC:
9ea033b2 1017 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1018 break;
1019
e9f53129
AM		 1020 case EM_SPU:
1021 rtype = elf_spu_reloc_type (type);
1022 break;
1023
2b0337b0 1024 case EM_V850:
252b5132 1025 case EM_CYGNUS_V850:
9ea033b2 1026 rtype = v850_reloc_type (type);
252b5132
RH		 1027 break;
1028
2b0337b0 1029 case EM_D10V:
252b5132 1030 case EM_CYGNUS_D10V:
9ea033b2 1031 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1032 break;
1033
2b0337b0 1034 case EM_D30V:
252b5132 1035 case EM_CYGNUS_D30V:
9ea033b2 1036 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1037 break;
1038
d172d4ba
NC		 1039 case EM_DLX:
1040 rtype = elf_dlx_reloc_type (type);
1041 break;
1042
252b5132 1043 case EM_SH:
9ea033b2 1044 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1045 break;
1046
2b0337b0 1047 case EM_MN10300:
252b5132 1048 case EM_CYGNUS_MN10300:
9ea033b2 1049 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1050 break;
1051
2b0337b0 1052 case EM_MN10200:
252b5132 1053 case EM_CYGNUS_MN10200:
9ea033b2 1054 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1055 break;
1056
2b0337b0 1057 case EM_FR30:
252b5132 1058 case EM_CYGNUS_FR30:
9ea033b2 1059 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1060 break;
1061
ba2685cc
AM		 1062 case EM_CYGNUS_FRV:
1063 rtype = elf_frv_reloc_type (type);
1064 break;
5c70f934 1065
252b5132 1066 case EM_MCORE:
9ea033b2 1067 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1068 break;
1069
3c3bdf30
NC		 1070 case EM_MMIX:
1071 rtype = elf_mmix_reloc_type (type);
1072 break;
1073
5506d11a
AM		 1074 case EM_MOXIE:
1075 rtype = elf_moxie_reloc_type (type);
1076 break;
1077
2469cfa2
NC		 1078 case EM_MSP430:
1079 case EM_MSP430_OLD:
1080 rtype = elf_msp430_reloc_type (type);
1081 break;
1082
252b5132 1083 case EM_PPC:
9ea033b2 1084 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1085 break;
1086
c833c019
AM		 1087 case EM_PPC64:
1088 rtype = elf_ppc64_reloc_type (type);
1089 break;
1090
252b5132 1091 case EM_MIPS:
4fe85591 1092 case EM_MIPS_RS3_LE:
9ea033b2 1093 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1094 break;
1095
1096 case EM_ALPHA:
9ea033b2 1097 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1098 break;
1099
1100 case EM_ARM:
9ea033b2 1101 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1102 break;
1103
584da044 1104 case EM_ARC:
9ea033b2 1105 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1106 break;
1107
1108 case EM_PARISC:
69e617ca 1109 rtype = elf_hppa_reloc_type (type);
252b5132 1110 break;
7d466069 1111
b8720f9d
JL		 1112 case EM_H8_300:
1113 case EM_H8_300H:
1114 case EM_H8S:
1115 rtype = elf_h8_reloc_type (type);
1116 break;
1117
3b16e843
NC		 1118 case EM_OPENRISC:
1119 case EM_OR32:
1120 rtype = elf_or32_reloc_type (type);
1121 break;
1122
7d466069 1123 case EM_PJ:
2b0337b0 1124 case EM_PJ_OLD:
7d466069
ILT		 1125 rtype = elf_pj_reloc_type (type);
1126 break;
800eeca4
JW		 1127 case EM_IA_64:
1128 rtype = elf_ia64_reloc_type (type);
1129 break;
1b61cf92
HPN		 1130
1131 case EM_CRIS:
1132 rtype = elf_cris_reloc_type (type);
1133 break;
535c37ff
JE		 1134
1135 case EM_860:
1136 rtype = elf_i860_reloc_type (type);
1137 break;
bcedfee6
NC		 1138
1139 case EM_X86_64:
8a9036a4 1140 case EM_L1OM:
bcedfee6
NC		 1141 rtype = elf_x86_64_reloc_type (type);
1142 break;
a85d7ed0 1143
35b1837e
AM		 1144 case EM_S370:
1145 rtype = i370_reloc_type (type);
1146 break;
1147
53c7db4b
KH		 1148 case EM_S390_OLD:
1149 case EM_S390:
1150 rtype = elf_s390_reloc_type (type);
1151 break;
93fbbb04 1152
1c0d3aa6
NC		 1153 case EM_SCORE:
1154 rtype = elf_score_reloc_type (type);
1155 break;
1156
93fbbb04
GK		 1157 case EM_XSTORMY16:
1158 rtype = elf_xstormy16_reloc_type (type);
1159 break;
179d3252 1160
1fe1f39c
NC		 1161 case EM_CRX:
1162 rtype = elf_crx_reloc_type (type);
1163 break;
1164
179d3252
JT		 1165 case EM_VAX:
1166 rtype = elf_vax_reloc_type (type);
1167 break;
1e4cf259
NC		 1168
1169 case EM_IP2K:
1170 case EM_IP2K_OLD:
1171 rtype = elf_ip2k_reloc_type (type);
1172 break;
3b36097d
SC		 1173
1174 case EM_IQ2000:
1175 rtype = elf_iq2000_reloc_type (type);
1176 break;
88da6820
NC		 1177
1178 case EM_XTENSA_OLD:
1179 case EM_XTENSA:
1180 rtype = elf_xtensa_reloc_type (type);
1181 break;
a34e3ecb 1182
84e94c90
NC		 1183 case EM_LATTICEMICO32:
1184 rtype = elf_lm32_reloc_type (type);
1185 break;
1186
ff7eeb89 1187 case EM_M32C_OLD:
49f58d10
JB		 1188 case EM_M32C:
1189 rtype = elf_m32c_reloc_type (type);
1190 break;
1191
d031aafb
NS		 1192 case EM_MT:
1193 rtype = elf_mt_reloc_type (type);
a34e3ecb 1194 break;
1d65ded4
CM		 1195
1196 case EM_BLACKFIN:
1197 rtype = elf_bfin_reloc_type (type);
1198 break;
15ab5209
DB		 1199
1200 case EM_CYGNUS_MEP:
1201 rtype = elf_mep_reloc_type (type);
1202 break;
60bca95a
NC		 1203
1204 case EM_CR16:
6c03b1ed 1205 case EM_CR16_OLD:
60bca95a
NC		 1206 rtype = elf_cr16_reloc_type (type);
1207 break;
dd24e3da 1208
7ba29e2a
NC		 1209 case EM_MICROBLAZE:
1210 case EM_MICROBLAZE_OLD:
1211 rtype = elf_microblaze_reloc_type (type);
1212 break;
c7927a3c
NC		 1213
1214 case EM_RX:
1215 rtype = elf_rx_reloc_type (type);
1216 break;
c29aca4a
NC		 1217
1218 case EM_XC16X:
1219 case EM_C166:
1220 rtype = elf_xc16x_reloc_type (type);
1221 break;
40b36596
JM		 1222
1223 case EM_TI_C6000:
1224 rtype = elf_tic6x_reloc_type (type);
1225 break;
aa137e4d
NC		 1226
1227 case EM_TILEGX:
1228 rtype = elf_tilegx_reloc_type (type);
1229 break;
1230
1231 case EM_TILEPRO:
1232 rtype = elf_tilepro_reloc_type (type);
1233 break;
252b5132
RH		 1234 }
1235
1236 if (rtype == NULL)
39dbeff8 1237 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1238 else
8beeaeb7 1239 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1240
7ace3541 1241 if (elf_header.e_machine == EM_ALPHA
157c2599 1242 && rtype != NULL
7ace3541
RH		 1243 && streq (rtype, "R_ALPHA_LITUSE")
1244 && is_rela)
1245 {
1246 switch (rels[i].r_addend)
1247 {
1248 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1249 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1250 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1251 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1252 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1253 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1254 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1255 default: rtype = NULL;
1256 }
1257 if (rtype)
1258 printf (" (%s)", rtype);
1259 else
1260 {
1261 putchar (' ');
1262 printf (_("<unknown addend: %lx>"),
1263 (unsigned long) rels[i].r_addend);
1264 }
1265 }
1266 else if (symtab_index)
252b5132 1267 {
af3fc3bc 1268 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1269 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1270 else
19936277 1271 {
2cf0635d 1272 Elf_Internal_Sym * psym;
19936277 1273
af3fc3bc 1274 psym = symtab + symtab_index;
103f02d3 1275
af3fc3bc 1276 printf (" ");
171191ba 1277
d8045f23
NC		 1278 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1279 {
1280 const char * name;
1281 unsigned int len;
1282 unsigned int width = is_32bit_elf ? 8 : 14;
1283
1284 /* Relocations against GNU_IFUNC symbols do not use the value
1285 of the symbol as the address to relocate against. Instead
1286 they invoke the function named by the symbol and use its
1287 result as the address for relocation.
1288
1289 To indicate this to the user, do not display the value of
1290 the symbol in the "Symbols's Value" field. Instead show
1291 its name followed by () as a hint that the symbol is
1292 invoked. */
1293
1294 if (strtab == NULL
1295 || psym->st_name == 0
1296 || psym->st_name >= strtablen)
1297 name = "??";
1298 else
1299 name = strtab + psym->st_name;
1300
1301 len = print_symbol (width, name);
1302 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1303 }
1304 else
1305 {
1306 print_vma (psym->st_value, LONG_HEX);
171191ba 1307
d8045f23
NC		 1308 printf (is_32bit_elf ? " " : " ");
1309 }
103f02d3 1310
af3fc3bc 1311 if (psym->st_name == 0)
f1ef08cb 1312 {
2cf0635d 1313 const char * sec_name = "<null>";
f1ef08cb
AM		 1314 char name_buf[40];
1315
1316 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1317 {
4fbb74a6
AM		 1318 if (psym->st_shndx < elf_header.e_shnum)
1319 sec_name
1320 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1321 else if (psym->st_shndx == SHN_ABS)
1322 sec_name = "ABS";
1323 else if (psym->st_shndx == SHN_COMMON)
1324 sec_name = "COMMON";
ac145307
BS		 1325 else if ((elf_header.e_machine == EM_MIPS
1326 && psym->st_shndx == SHN_MIPS_SCOMMON)
1327 || (elf_header.e_machine == EM_TI_C6000
1328 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1329 sec_name = "SCOMMON";
1330 else if (elf_header.e_machine == EM_MIPS
1331 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1332 sec_name = "SUNDEF";
8a9036a4
L		 1333 else if ((elf_header.e_machine == EM_X86_64
1334 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 1335 && psym->st_shndx == SHN_X86_64_LCOMMON)
1336 sec_name = "LARGE_COMMON";
9ce701e2
L		 1337 else if (elf_header.e_machine == EM_IA_64
1338 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1339 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1340 sec_name = "ANSI_COM";
28f997cf 1341 else if (is_ia64_vms ()
148b93f2
NC		 1342 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1343 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1344 else
1345 {
1346 sprintf (name_buf, "<section 0x%x>",
1347 (unsigned int) psym->st_shndx);
1348 sec_name = name_buf;
1349 }
1350 }
1351 print_symbol (22, sec_name);
1352 }
af3fc3bc 1353 else if (strtab == NULL)
d79b3d50 1354 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1355 else if (psym->st_name >= strtablen)
d79b3d50 1356 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1357 else
2c71103e 1358 print_symbol (22, strtab + psym->st_name);
103f02d3 1359
af3fc3bc 1360 if (is_rela)
171191ba 1361 {
598aaa76 1362 bfd_signed_vma off = rels[i].r_addend;
171191ba 1363
91d6fa6a 1364 if (off < 0)
598aaa76 1365 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1366 else
598aaa76 1367 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1368 }
19936277 1369 }
252b5132 1370 }
1b228002 1371 else if (is_rela)
f7a99963 1372 {
18bd398b
NC		 1373 printf ("%*c", is_32bit_elf ?
1374 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1375 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1376 }
252b5132 1377
157c2599
NC		 1378 if (elf_header.e_machine == EM_SPARCV9
1379 && rtype != NULL
1380 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1381 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1382
252b5132 1383 putchar ('\n');
2c71103e 1384
aca88567 1385#ifdef BFD64
53c7db4b 1386 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1387 {
91d6fa6a
NC		 1388 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1389 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1390 const char * rtype2 = elf_mips_reloc_type (type2);
1391 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1392
2c71103e
NC		 1393 printf (" Type2: ");
1394
1395 if (rtype2 == NULL)
39dbeff8
AM		 1396 printf (_("unrecognized: %-7lx"),
1397 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1398 else
1399 printf ("%-17.17s", rtype2);
1400
18bd398b 1401 printf ("\n Type3: ");
2c71103e
NC		 1402
1403 if (rtype3 == NULL)
39dbeff8
AM		 1404 printf (_("unrecognized: %-7lx"),
1405 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1406 else
1407 printf ("%-17.17s", rtype3);
1408
53c7db4b 1409 putchar ('\n');
2c71103e 1410 }
aca88567 1411#endif /* BFD64 */
252b5132
RH		 1412 }
1413
c8286bd1 1414 free (rels);
252b5132
RH		 1415}
1416
1417static const char *
d3ba0551 1418get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1419{
1420 switch (type)
1421 {
1422 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1423 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1424 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1425 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1426 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1427 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1428 case DT_MIPS_MSYM: return "MIPS_MSYM";
1429 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1430 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1431 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1432 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1433 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1434 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1435 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1436 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1437 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1438 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1439 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1440 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1441 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1442 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1443 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1444 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1445 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1446 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1447 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1448 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1449 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1450 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1451 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1452 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1453 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1454 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1455 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1456 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1457 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1458 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1459 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1460 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1461 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1462 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1463 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1464 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1465 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1466 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1467 default:
1468 return NULL;
1469 }
1470}
1471
9a097730 1472static const char *
d3ba0551 1473get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1474{
1475 switch (type)
1476 {
1477 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1478 default:
1479 return NULL;
1480 }
103f02d3
UD		 1481}
1482
7490d522
AM		 1483static const char *
1484get_ppc_dynamic_type (unsigned long type)
1485{
1486 switch (type)
1487 {
a7f2871e
AM		 1488 case DT_PPC_GOT: return "PPC_GOT";
1489 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1490 default:
1491 return NULL;
1492 }
1493}
1494
f1cb7e17 1495static const char *
d3ba0551 1496get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1497{
1498 switch (type)
1499 {
a7f2871e
AM		 1500 case DT_PPC64_GLINK: return "PPC64_GLINK";
1501 case DT_PPC64_OPD: return "PPC64_OPD";
1502 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1503 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1504 default:
1505 return NULL;
1506 }
1507}
1508
103f02d3 1509static const char *
d3ba0551 1510get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1511{
1512 switch (type)
1513 {
1514 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1515 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1516 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1517 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1518 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1519 case DT_HP_PREINIT: return "HP_PREINIT";
1520 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1521 case DT_HP_NEEDED: return "HP_NEEDED";
1522 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1523 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1524 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1525 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1526 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1527 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1528 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1529 case DT_HP_FILTERED: return "HP_FILTERED";
1530 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1531 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1532 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1533 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1534 case DT_PLT: return "PLT";
1535 case DT_PLT_SIZE: return "PLT_SIZE";
1536 case DT_DLT: return "DLT";
1537 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1538 default:
1539 return NULL;
1540 }
1541}
9a097730 1542
ecc51f48 1543static const char *
d3ba0551 1544get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1545{
1546 switch (type)
1547 {
148b93f2
NC		 1548 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1549 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1550 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1551 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1552 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1553 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1554 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1555 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1556 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1557 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1558 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1559 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1560 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1561 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1562 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1563 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1564 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1565 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1566 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1567 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1568 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1569 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1570 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1571 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1572 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1573 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1574 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1575 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1576 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1577 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1578 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1579 default:
1580 return NULL;
1581 }
1582}
1583
fabcb361
RH		 1584static const char *
1585get_alpha_dynamic_type (unsigned long type)
1586{
1587 switch (type)
1588 {
1589 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1590 default:
1591 return NULL;
1592 }
1593}
1594
1c0d3aa6
NC		 1595static const char *
1596get_score_dynamic_type (unsigned long type)
1597{
1598 switch (type)
1599 {
1600 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1601 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1602 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1603 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1604 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1605 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1606 default:
1607 return NULL;
1608 }
1609}
1610
40b36596
JM		 1611static const char *
1612get_tic6x_dynamic_type (unsigned long type)
1613{
1614 switch (type)
1615 {
1616 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1617 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1618 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1619 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1620 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1621 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1622 default:
1623 return NULL;
1624 }
1625}
1c0d3aa6 1626
252b5132 1627static const char *
d3ba0551 1628get_dynamic_type (unsigned long type)
252b5132 1629{
e9e44622 1630 static char buff[64];
252b5132
RH		 1631
1632 switch (type)
1633 {
1634 case DT_NULL: return "NULL";
1635 case DT_NEEDED: return "NEEDED";
1636 case DT_PLTRELSZ: return "PLTRELSZ";
1637 case DT_PLTGOT: return "PLTGOT";
1638 case DT_HASH: return "HASH";
1639 case DT_STRTAB: return "STRTAB";
1640 case DT_SYMTAB: return "SYMTAB";
1641 case DT_RELA: return "RELA";
1642 case DT_RELASZ: return "RELASZ";
1643 case DT_RELAENT: return "RELAENT";
1644 case DT_STRSZ: return "STRSZ";
1645 case DT_SYMENT: return "SYMENT";
1646 case DT_INIT: return "INIT";
1647 case DT_FINI: return "FINI";
1648 case DT_SONAME: return "SONAME";
1649 case DT_RPATH: return "RPATH";
1650 case DT_SYMBOLIC: return "SYMBOLIC";
1651 case DT_REL: return "REL";
1652 case DT_RELSZ: return "RELSZ";
1653 case DT_RELENT: return "RELENT";
1654 case DT_PLTREL: return "PLTREL";
1655 case DT_DEBUG: return "DEBUG";
1656 case DT_TEXTREL: return "TEXTREL";
1657 case DT_JMPREL: return "JMPREL";
1658 case DT_BIND_NOW: return "BIND_NOW";
1659 case DT_INIT_ARRAY: return "INIT_ARRAY";
1660 case DT_FINI_ARRAY: return "FINI_ARRAY";
1661 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1662 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1663 case DT_RUNPATH: return "RUNPATH";
1664 case DT_FLAGS: return "FLAGS";
2d0e6f43 1665
d1133906
NC		 1666 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1667 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1668
05107a46 1669 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1670 case DT_PLTPADSZ: return "PLTPADSZ";
1671 case DT_MOVEENT: return "MOVEENT";
1672 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1673 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1674 case DT_POSFLAG_1: return "POSFLAG_1";
1675 case DT_SYMINSZ: return "SYMINSZ";
1676 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1677
252b5132 1678 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1679 case DT_CONFIG: return "CONFIG";
1680 case DT_DEPAUDIT: return "DEPAUDIT";
1681 case DT_AUDIT: return "AUDIT";
1682 case DT_PLTPAD: return "PLTPAD";
1683 case DT_MOVETAB: return "MOVETAB";
252b5132 1684 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1685
252b5132 1686 case DT_VERSYM: return "VERSYM";
103f02d3 1687
67a4f2b7
AO		 1688 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1689 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1690 case DT_RELACOUNT: return "RELACOUNT";
1691 case DT_RELCOUNT: return "RELCOUNT";
1692 case DT_FLAGS_1: return "FLAGS_1";
1693 case DT_VERDEF: return "VERDEF";
1694 case DT_VERDEFNUM: return "VERDEFNUM";
1695 case DT_VERNEED: return "VERNEED";
1696 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1697
019148e4 1698 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1699 case DT_USED: return "USED";
1700 case DT_FILTER: return "FILTER";
103f02d3 1701
047b2264
JJ		 1702 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1703 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1704 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1705 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1706 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1707 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1708
252b5132
RH		 1709 default:
1710 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1711 {
2cf0635d 1712 const char * result;
103f02d3 1713
252b5132
RH		 1714 switch (elf_header.e_machine)
1715 {
1716 case EM_MIPS:
4fe85591 1717 case EM_MIPS_RS3_LE:
252b5132
RH		 1718 result = get_mips_dynamic_type (type);
1719 break;
9a097730
RH		 1720 case EM_SPARCV9:
1721 result = get_sparc64_dynamic_type (type);
1722 break;
7490d522
AM		 1723 case EM_PPC:
1724 result = get_ppc_dynamic_type (type);
1725 break;
f1cb7e17
AM		 1726 case EM_PPC64:
1727 result = get_ppc64_dynamic_type (type);
1728 break;
ecc51f48
NC		 1729 case EM_IA_64:
1730 result = get_ia64_dynamic_type (type);
1731 break;
fabcb361
RH		 1732 case EM_ALPHA:
1733 result = get_alpha_dynamic_type (type);
1734 break;
1c0d3aa6
NC		 1735 case EM_SCORE:
1736 result = get_score_dynamic_type (type);
1737 break;
40b36596
JM		 1738 case EM_TI_C6000:
1739 result = get_tic6x_dynamic_type (type);
1740 break;
252b5132
RH		 1741 default:
1742 result = NULL;
1743 break;
1744 }
1745
1746 if (result != NULL)
1747 return result;
1748
e9e44622 1749 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1750 }
eec8f817
DA		 1751 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1752 || (elf_header.e_machine == EM_PARISC
1753 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1754 {
2cf0635d 1755 const char * result;
103f02d3
UD		 1756
1757 switch (elf_header.e_machine)
1758 {
1759 case EM_PARISC:
1760 result = get_parisc_dynamic_type (type);
1761 break;
148b93f2
NC		 1762 case EM_IA_64:
1763 result = get_ia64_dynamic_type (type);
1764 break;
103f02d3
UD		 1765 default:
1766 result = NULL;
1767 break;
1768 }
1769
1770 if (result != NULL)
1771 return result;
1772
e9e44622
JJ		 1773 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1774 type);
103f02d3 1775 }
252b5132 1776 else
e9e44622 1777 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1778
252b5132
RH		 1779 return buff;
1780 }
1781}
1782
1783static char *
d3ba0551 1784get_file_type (unsigned e_type)
252b5132 1785{
b34976b6 1786 static char buff[32];
252b5132
RH		 1787
1788 switch (e_type)
1789 {
1790 case ET_NONE: return _("NONE (None)");
1791 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1792 case ET_EXEC: return _("EXEC (Executable file)");
1793 case ET_DYN: return _("DYN (Shared object file)");
1794 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1795
1796 default:
1797 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1798 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1799 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1800 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1801 else
e9e44622 1802 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1803 return buff;
1804 }
1805}
1806
1807static char *
d3ba0551 1808get_machine_name (unsigned e_machine)
252b5132 1809{
b34976b6 1810 static char buff[64]; /* XXX */
252b5132
RH		 1811
1812 switch (e_machine)
1813 {
c45021f2
NC		 1814 case EM_NONE: return _("None");
1815 case EM_M32: return "WE32100";
1816 case EM_SPARC: return "Sparc";
e9f53129 1817 case EM_SPU: return "SPU";
c45021f2
NC		 1818 case EM_386: return "Intel 80386";
1819 case EM_68K: return "MC68000";
1820 case EM_88K: return "MC88000";
1821 case EM_486: return "Intel 80486";
1822 case EM_860: return "Intel 80860";
1823 case EM_MIPS: return "MIPS R3000";
1824 case EM_S370: return "IBM System/370";
7036c0e1 1825 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1826 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1827 case EM_PARISC: return "HPPA";
252b5132 1828 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1829 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1830 case EM_960: return "Intel 90860";
1831 case EM_PPC: return "PowerPC";
285d1771 1832 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1833 case EM_V800: return "NEC V800";
1834 case EM_FR20: return "Fujitsu FR20";
1835 case EM_RH32: return "TRW RH32";
b34976b6 1836 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1837 case EM_ARM: return "ARM";
1838 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1839 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1840 case EM_SPARCV9: return "Sparc v9";
1841 case EM_TRICORE: return "Siemens Tricore";
584da044 1842 case EM_ARC: return "ARC";
c2dcd04e
NC		 1843 case EM_H8_300: return "Renesas H8/300";
1844 case EM_H8_300H: return "Renesas H8/300H";
1845 case EM_H8S: return "Renesas H8S";
1846 case EM_H8_500: return "Renesas H8/500";
30800947 1847 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1848 case EM_MIPS_X: return "Stanford MIPS-X";
1849 case EM_COLDFIRE: return "Motorola Coldfire";
1850 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1851 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1852 case EM_CYGNUS_D10V:
1853 case EM_D10V: return "d10v";
1854 case EM_CYGNUS_D30V:
b34976b6 1855 case EM_D30V: return "d30v";
2b0337b0 1856 case EM_CYGNUS_M32R:
26597c86 1857 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1858 case EM_CYGNUS_V850:
8f7e76d0 1859 case EM_V850: return "Renesas v850";
2b0337b0
AO		 1860 case EM_CYGNUS_MN10300:
1861 case EM_MN10300: return "mn10300";
1862 case EM_CYGNUS_MN10200:
1863 case EM_MN10200: return "mn10200";
5506d11a 1864 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1865 case EM_CYGNUS_FR30:
1866 case EM_FR30: return "Fujitsu FR30";
b34976b6 1867 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1868 case EM_PJ_OLD:
b34976b6 1869 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1870 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1871 case EM_PCP: return "Siemens PCP";
1872 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1873 case EM_NDR1: return "Denso NDR1 microprocesspr";
1874 case EM_STARCORE: return "Motorola Star*Core processor";
1875 case EM_ME16: return "Toyota ME16 processor";
1876 case EM_ST100: return "STMicroelectronics ST100 processor";
1877 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1878 case EM_PDSP: return "Sony DSP processor";
1879 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1880 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1881 case EM_FX66: return "Siemens FX66 microcontroller";
1882 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1883 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1884 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1885 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1886 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1887 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1888 case EM_SVX: return "Silicon Graphics SVx";
1889 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1890 case EM_VAX: return "Digital VAX";
2b0337b0 1891 case EM_AVR_OLD:
b34976b6 1892 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1893 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1894 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1895 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1896 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1897 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1898 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1899 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1900 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1901 case EM_L1OM: return "Intel L1OM";
b7498e0e 1902 case EM_S390_OLD:
b34976b6 1903 case EM_S390: return "IBM S/390";
1c0d3aa6 1904 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1905 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1906 case EM_OPENRISC:
1907 case EM_OR32: return "OpenRISC";
11636f9e 1908 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1909 case EM_CRX: return "National Semiconductor CRX microprocessor";
d172d4ba 1910 case EM_DLX: return "OpenDLX";
1e4cf259 1911 case EM_IP2K_OLD:
b34976b6 1912 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1913 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1914 case EM_XTENSA_OLD:
1915 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1916 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1917 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1918 case EM_NS32K: return "National Semiconductor 32000 series";
1919 case EM_TPC: return "Tenor Network TPC processor";
1920 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1921 case EM_MAX: return "MAX Processor";
1922 case EM_CR: return "National Semiconductor CompactRISC";
1923 case EM_F2MC16: return "Fujitsu F2MC16";
1924 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1925 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1926 case EM_M32C_OLD:
49f58d10 1927 case EM_M32C: return "Renesas M32c";
d031aafb 1928 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1929 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1930 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1931 case EM_SEP: return "Sharp embedded microprocessor";
1932 case EM_ARCA: return "Arca RISC microprocessor";
1933 case EM_UNICORE: return "Unicore";
1934 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1935 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1936 case EM_NIOS32: return "Altera Nios";
1937 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1938 case EM_C166:
d70c5fc7 1939 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1940 case EM_M16C: return "Renesas M16C series microprocessors";
1941 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1942 case EM_CE: return "Freescale Communication Engine RISC core";
1943 case EM_TSK3000: return "Altium TSK3000 core";
1944 case EM_RS08: return "Freescale RS08 embedded processor";
1945 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1946 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1947 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1948 case EM_SE_C17: return "Seiko Epson C17 family";
1949 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1950 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1951 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1952 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1953 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1954 case EM_R32C: return "Renesas R32C series microprocessors";
1955 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1956 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1957 case EM_8051: return "Intel 8051 and variants";
1958 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1959 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1960 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1961 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1962 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1963 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1964 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1965 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1966 case EM_CR16:
6c03b1ed 1967 case EM_CR16_OLD: return "National Semiconductor's CR16";
7ba29e2a
NC		 1968 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1969 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
c7927a3c 1970 case EM_RX: return "Renesas RX";
11636f9e
JM		 1971 case EM_METAG: return "Imagination Technologies META processor architecture";
1972 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1973 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1974 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1975 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1976 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1977 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1978 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1979 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 1980 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 1981 case EM_CUDA: return "NVIDIA CUDA architecture";
252b5132 1982 default:
35d9dd2f 1983 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 1984 return buff;
1985 }
1986}
1987
f3485b74 1988static void
d3ba0551 1989decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 1990{
1991 unsigned eabi;
1992 int unknown = 0;
1993
1994 eabi = EF_ARM_EABI_VERSION (e_flags);
1995 e_flags &= ~ EF_ARM_EABIMASK;
1996
1997 /* Handle "generic" ARM flags. */
1998 if (e_flags & EF_ARM_RELEXEC)
1999 {
2000 strcat (buf, ", relocatable executable");
2001 e_flags &= ~ EF_ARM_RELEXEC;
2002 }
76da6bbe 2003
f3485b74
NC		 2004 if (e_flags & EF_ARM_HASENTRY)
2005 {
2006 strcat (buf, ", has entry point");
2007 e_flags &= ~ EF_ARM_HASENTRY;
2008 }
76da6bbe 2009
f3485b74
NC		 2010 /* Now handle EABI specific flags. */
2011 switch (eabi)
2012 {
2013 default:
2c71103e 2014 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2015 if (e_flags)
2016 unknown = 1;
2017 break;
2018
2019 case EF_ARM_EABI_VER1:
a5bcd848 2020 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2021 while (e_flags)
2022 {
2023 unsigned flag;
76da6bbe 2024
f3485b74
NC		 2025 /* Process flags one bit at a time. */
2026 flag = e_flags & - e_flags;
2027 e_flags &= ~ flag;
76da6bbe 2028
f3485b74
NC		 2029 switch (flag)
2030 {
a5bcd848 2031 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2032 strcat (buf, ", sorted symbol tables");
2033 break;
76da6bbe 2034
f3485b74
NC		 2035 default:
2036 unknown = 1;
2037 break;
2038 }
2039 }
2040 break;
76da6bbe 2041
a5bcd848
PB		 2042 case EF_ARM_EABI_VER2:
2043 strcat (buf, ", Version2 EABI");
2044 while (e_flags)
2045 {
2046 unsigned flag;
2047
2048 /* Process flags one bit at a time. */
2049 flag = e_flags & - e_flags;
2050 e_flags &= ~ flag;
2051
2052 switch (flag)
2053 {
2054 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2055 strcat (buf, ", sorted symbol tables");
2056 break;
2057
2058 case EF_ARM_DYNSYMSUSESEGIDX:
2059 strcat (buf, ", dynamic symbols use segment index");
2060 break;
2061
2062 case EF_ARM_MAPSYMSFIRST:
2063 strcat (buf, ", mapping symbols precede others");
2064 break;
2065
2066 default:
2067 unknown = 1;
2068 break;
2069 }
2070 }
2071 break;
2072
d507cf36
PB		 2073 case EF_ARM_EABI_VER3:
2074 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2075 break;
2076
2077 case EF_ARM_EABI_VER4:
2078 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2079 goto eabi;
2080
2081 case EF_ARM_EABI_VER5:
2082 strcat (buf, ", Version5 EABI");
2083 eabi:
d507cf36
PB		 2084 while (e_flags)
2085 {
2086 unsigned flag;
2087
2088 /* Process flags one bit at a time. */
2089 flag = e_flags & - e_flags;
2090 e_flags &= ~ flag;
2091
2092 switch (flag)
2093 {
2094 case EF_ARM_BE8:
2095 strcat (buf, ", BE8");
2096 break;
2097
2098 case EF_ARM_LE8:
2099 strcat (buf, ", LE8");
2100 break;
2101
2102 default:
2103 unknown = 1;
2104 break;
2105 }
2106 }
2107 break;
2108
f3485b74 2109 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2110 strcat (buf, ", GNU EABI");
f3485b74
NC		 2111 while (e_flags)
2112 {
2113 unsigned flag;
76da6bbe 2114
f3485b74
NC		 2115 /* Process flags one bit at a time. */
2116 flag = e_flags & - e_flags;
2117 e_flags &= ~ flag;
76da6bbe 2118
f3485b74
NC		 2119 switch (flag)
2120 {
a5bcd848 2121 case EF_ARM_INTERWORK:
f3485b74
NC		 2122 strcat (buf, ", interworking enabled");
2123 break;
76da6bbe 2124
a5bcd848 2125 case EF_ARM_APCS_26:
f3485b74
NC		 2126 strcat (buf, ", uses APCS/26");
2127 break;
76da6bbe 2128
a5bcd848 2129 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2130 strcat (buf, ", uses APCS/float");
2131 break;
76da6bbe 2132
a5bcd848 2133 case EF_ARM_PIC:
f3485b74
NC		 2134 strcat (buf, ", position independent");
2135 break;
76da6bbe 2136
a5bcd848 2137 case EF_ARM_ALIGN8:
f3485b74
NC		 2138 strcat (buf, ", 8 bit structure alignment");
2139 break;
76da6bbe 2140
a5bcd848 2141 case EF_ARM_NEW_ABI:
f3485b74
NC		 2142 strcat (buf, ", uses new ABI");
2143 break;
76da6bbe 2144
a5bcd848 2145 case EF_ARM_OLD_ABI:
f3485b74
NC		 2146 strcat (buf, ", uses old ABI");
2147 break;
76da6bbe 2148
a5bcd848 2149 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2150 strcat (buf, ", software FP");
2151 break;
76da6bbe 2152
90e01f86
ILT		 2153 case EF_ARM_VFP_FLOAT:
2154 strcat (buf, ", VFP");
2155 break;
2156
fde78edd
NC		 2157 case EF_ARM_MAVERICK_FLOAT:
2158 strcat (buf, ", Maverick FP");
2159 break;
2160
f3485b74
NC		 2161 default:
2162 unknown = 1;
2163 break;
2164 }
2165 }
2166 }
f3485b74
NC		 2167
2168 if (unknown)
2b692964 2169 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2170}
2171
252b5132 2172static char *
d3ba0551 2173get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2174{
b34976b6 2175 static char buf[1024];
252b5132
RH		 2176
2177 buf[0] = '\0';
76da6bbe 2178
252b5132
RH		 2179 if (e_flags)
2180 {
2181 switch (e_machine)
2182 {
2183 default:
2184 break;
2185
f3485b74
NC		 2186 case EM_ARM:
2187 decode_ARM_machine_flags (e_flags, buf);
2188 break;
76da6bbe 2189
781303ce
MF		 2190 case EM_BLACKFIN:
2191 if (e_flags & EF_BFIN_PIC)
2192 strcat (buf, ", PIC");
2193
2194 if (e_flags & EF_BFIN_FDPIC)
2195 strcat (buf, ", FDPIC");
2196
2197 if (e_flags & EF_BFIN_CODE_IN_L1)
2198 strcat (buf, ", code in L1");
2199
2200 if (e_flags & EF_BFIN_DATA_IN_L1)
2201 strcat (buf, ", data in L1");
2202
2203 break;
2204
ec2dfb42
AO		 2205 case EM_CYGNUS_FRV:
2206 switch (e_flags & EF_FRV_CPU_MASK)
2207 {
2208 case EF_FRV_CPU_GENERIC:
2209 break;
2210
2211 default:
2212 strcat (buf, ", fr???");
2213 break;
57346661 2214
ec2dfb42
AO		 2215 case EF_FRV_CPU_FR300:
2216 strcat (buf, ", fr300");
2217 break;
2218
2219 case EF_FRV_CPU_FR400:
2220 strcat (buf, ", fr400");
2221 break;
2222 case EF_FRV_CPU_FR405:
2223 strcat (buf, ", fr405");
2224 break;
2225
2226 case EF_FRV_CPU_FR450:
2227 strcat (buf, ", fr450");
2228 break;
2229
2230 case EF_FRV_CPU_FR500:
2231 strcat (buf, ", fr500");
2232 break;
2233 case EF_FRV_CPU_FR550:
2234 strcat (buf, ", fr550");
2235 break;
2236
2237 case EF_FRV_CPU_SIMPLE:
2238 strcat (buf, ", simple");
2239 break;
2240 case EF_FRV_CPU_TOMCAT:
2241 strcat (buf, ", tomcat");
2242 break;
2243 }
1c877e87 2244 break;
ec2dfb42 2245
53c7db4b 2246 case EM_68K:
425c6cb0 2247 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2248 strcat (buf, ", m68000");
425c6cb0 2249 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2250 strcat (buf, ", cpu32");
2251 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2252 strcat (buf, ", fido_a");
425c6cb0 2253 else
266abb8f 2254 {
2cf0635d
NC		 2255 char const * isa = _("unknown");
2256 char const * mac = _("unknown mac");
2257 char const * additional = NULL;
0112cd26 2258
c694fd50 2259 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2260 {
c694fd50 2261 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2262 isa = "A";
2263 additional = ", nodiv";
2264 break;
c694fd50 2265 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2266 isa = "A";
2267 break;
c694fd50 2268 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2269 isa = "A+";
2270 break;
c694fd50 2271 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2272 isa = "B";
2273 additional = ", nousp";
2274 break;
c694fd50 2275 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2276 isa = "B";
2277 break;
f608cd77
NS		 2278 case EF_M68K_CF_ISA_C:
2279 isa = "C";
2280 break;
2281 case EF_M68K_CF_ISA_C_NODIV:
2282 isa = "C";
2283 additional = ", nodiv";
2284 break;
266abb8f
NS		 2285 }
2286 strcat (buf, ", cf, isa ");
2287 strcat (buf, isa);
0b2e31dc
NS		 2288 if (additional)
2289 strcat (buf, additional);
c694fd50 2290 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2291 strcat (buf, ", float");
c694fd50 2292 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2293 {
2294 case 0:
2295 mac = NULL;
2296 break;
c694fd50 2297 case EF_M68K_CF_MAC:
266abb8f
NS		 2298 mac = "mac";
2299 break;
c694fd50 2300 case EF_M68K_CF_EMAC:
266abb8f
NS		 2301 mac = "emac";
2302 break;
f608cd77
NS		 2303 case EF_M68K_CF_EMAC_B:
2304 mac = "emac_b";
2305 break;
266abb8f
NS		 2306 }
2307 if (mac)
2308 {
2309 strcat (buf, ", ");
2310 strcat (buf, mac);
2311 }
266abb8f 2312 }
53c7db4b 2313 break;
33c63f9d 2314
252b5132
RH		 2315 case EM_PPC:
2316 if (e_flags & EF_PPC_EMB)
2317 strcat (buf, ", emb");
2318
2319 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2320 strcat (buf, _(", relocatable"));
252b5132
RH		 2321
2322 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2323 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2324 break;
2325
2b0337b0 2326 case EM_V850:
252b5132
RH		 2327 case EM_CYGNUS_V850:
2328 switch (e_flags & EF_V850_ARCH)
2329 {
1cd986c5
NC		 2330 case E_V850E2V3_ARCH:
2331 strcat (buf, ", v850e2v3");
2332 break;
2333 case E_V850E2_ARCH:
2334 strcat (buf, ", v850e2");
2335 break;
2336 case E_V850E1_ARCH:
2337 strcat (buf, ", v850e1");
8ad30312 2338 break;
252b5132
RH		 2339 case E_V850E_ARCH:
2340 strcat (buf, ", v850e");
2341 break;
252b5132
RH		 2342 case E_V850_ARCH:
2343 strcat (buf, ", v850");
2344 break;
2345 default:
2b692964 2346 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2347 break;
2348 }
2349 break;
2350
2b0337b0 2351 case EM_M32R:
252b5132
RH		 2352 case EM_CYGNUS_M32R:
2353 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2354 strcat (buf, ", m32r");
252b5132
RH		 2355 break;
2356
2357 case EM_MIPS:
4fe85591 2358 case EM_MIPS_RS3_LE:
252b5132
RH		 2359 if (e_flags & EF_MIPS_NOREORDER)
2360 strcat (buf, ", noreorder");
2361
2362 if (e_flags & EF_MIPS_PIC)
2363 strcat (buf, ", pic");
2364
2365 if (e_flags & EF_MIPS_CPIC)
2366 strcat (buf, ", cpic");
2367
d1bdd336
TS		 2368 if (e_flags & EF_MIPS_UCODE)
2369 strcat (buf, ", ugen_reserved");
2370
252b5132
RH		 2371 if (e_flags & EF_MIPS_ABI2)
2372 strcat (buf, ", abi2");
2373
43521d43
TS		 2374 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2375 strcat (buf, ", odk first");
2376
a5d22d2a
TS		 2377 if (e_flags & EF_MIPS_32BITMODE)
2378 strcat (buf, ", 32bitmode");
2379
156c2f8b
NC		 2380 switch ((e_flags & EF_MIPS_MACH))
2381 {
2382 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2383 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2384 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2385 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2386 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2387 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2388 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2389 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2390 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2391 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2392 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2393 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2394 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2395 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2396 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2397 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2398 case 0:
2399 /* We simply ignore the field in this case to avoid confusion:
2400 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2401 extension. */
2402 break;
2b692964 2403 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2404 }
43521d43
TS		 2405
2406 switch ((e_flags & EF_MIPS_ABI))
2407 {
2408 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2409 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2410 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2411 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2412 case 0:
2413 /* We simply ignore the field in this case to avoid confusion:
2414 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2415 This means it is likely to be an o32 file, but not for
2416 sure. */
2417 break;
2b692964 2418 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2419 }
2420
2421 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2422 strcat (buf, ", mdmx");
2423
2424 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2425 strcat (buf, ", mips16");
2426
2427 switch ((e_flags & EF_MIPS_ARCH))
2428 {
2429 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2430 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2431 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2432 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2433 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2434 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2435 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2436 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2437 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2438 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2439 }
2440
8e45593f
NC		 2441 if (e_flags & EF_SH_PIC)
2442 strcat (buf, ", pic");
2443
2444 if (e_flags & EF_SH_FDPIC)
2445 strcat (buf, ", fdpic");
252b5132 2446 break;
351b4b40 2447
ccde1100
AO		 2448 case EM_SH:
2449 switch ((e_flags & EF_SH_MACH_MASK))
2450 {
2451 case EF_SH1: strcat (buf, ", sh1"); break;
2452 case EF_SH2: strcat (buf, ", sh2"); break;
2453 case EF_SH3: strcat (buf, ", sh3"); break;
2454 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2455 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2456 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2457 case EF_SH3E: strcat (buf, ", sh3e"); break;
2458 case EF_SH4: strcat (buf, ", sh4"); break;
2459 case EF_SH5: strcat (buf, ", sh5"); break;
2460 case EF_SH2E: strcat (buf, ", sh2e"); break;
2461 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2462 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2463 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2464 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2465 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2466 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2467 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2468 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2469 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2470 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2471 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2472 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2473 }
2474
2475 break;
57346661 2476
351b4b40
RH		 2477 case EM_SPARCV9:
2478 if (e_flags & EF_SPARC_32PLUS)
2479 strcat (buf, ", v8+");
2480
2481 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2482 strcat (buf, ", ultrasparcI");
2483
2484 if (e_flags & EF_SPARC_SUN_US3)
2485 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2486
2487 if (e_flags & EF_SPARC_HAL_R1)
2488 strcat (buf, ", halr1");
2489
2490 if (e_flags & EF_SPARC_LEDATA)
2491 strcat (buf, ", ledata");
2492
2493 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2494 strcat (buf, ", tso");
2495
2496 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2497 strcat (buf, ", pso");
2498
2499 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2500 strcat (buf, ", rmo");
2501 break;
7d466069 2502
103f02d3
UD		 2503 case EM_PARISC:
2504 switch (e_flags & EF_PARISC_ARCH)
2505 {
2506 case EFA_PARISC_1_0:
2507 strcpy (buf, ", PA-RISC 1.0");
2508 break;
2509 case EFA_PARISC_1_1:
2510 strcpy (buf, ", PA-RISC 1.1");
2511 break;
2512 case EFA_PARISC_2_0:
2513 strcpy (buf, ", PA-RISC 2.0");
2514 break;
2515 default:
2516 break;
2517 }
2518 if (e_flags & EF_PARISC_TRAPNIL)
2519 strcat (buf, ", trapnil");
2520 if (e_flags & EF_PARISC_EXT)
2521 strcat (buf, ", ext");
2522 if (e_flags & EF_PARISC_LSB)
2523 strcat (buf, ", lsb");
2524 if (e_flags & EF_PARISC_WIDE)
2525 strcat (buf, ", wide");
2526 if (e_flags & EF_PARISC_NO_KABP)
2527 strcat (buf, ", no kabp");
2528 if (e_flags & EF_PARISC_LAZYSWAP)
2529 strcat (buf, ", lazyswap");
30800947 2530 break;
76da6bbe 2531
7d466069 2532 case EM_PJ:
2b0337b0 2533 case EM_PJ_OLD:
7d466069
ILT		 2534 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2535 strcat (buf, ", new calling convention");
2536
2537 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2538 strcat (buf, ", gnu calling convention");
2539 break;
4d6ed7c8
NC		 2540
2541 case EM_IA_64:
2542 if ((e_flags & EF_IA_64_ABI64))
2543 strcat (buf, ", 64-bit");
2544 else
2545 strcat (buf, ", 32-bit");
2546 if ((e_flags & EF_IA_64_REDUCEDFP))
2547 strcat (buf, ", reduced fp model");
2548 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2549 strcat (buf, ", no function descriptors, constant gp");
2550 else if ((e_flags & EF_IA_64_CONS_GP))
2551 strcat (buf, ", constant gp");
2552 if ((e_flags & EF_IA_64_ABSOLUTE))
2553 strcat (buf, ", absolute");
28f997cf
TG		 2554 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2555 {
2556 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2557 strcat (buf, ", vms_linkages");
2558 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2559 {
2560 case EF_IA_64_VMS_COMCOD_SUCCESS:
2561 break;
2562 case EF_IA_64_VMS_COMCOD_WARNING:
2563 strcat (buf, ", warning");
2564 break;
2565 case EF_IA_64_VMS_COMCOD_ERROR:
2566 strcat (buf, ", error");
2567 break;
2568 case EF_IA_64_VMS_COMCOD_ABORT:
2569 strcat (buf, ", abort");
2570 break;
2571 default:
2572 abort ();
2573 }
2574 }
4d6ed7c8 2575 break;
179d3252
JT		 2576
2577 case EM_VAX:
2578 if ((e_flags & EF_VAX_NONPIC))
2579 strcat (buf, ", non-PIC");
2580 if ((e_flags & EF_VAX_DFLOAT))
2581 strcat (buf, ", D-Float");
2582 if ((e_flags & EF_VAX_GFLOAT))
2583 strcat (buf, ", G-Float");
2584 break;
c7927a3c
NC		 2585
2586 case EM_RX:
2587 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2588 strcat (buf, ", 64-bit doubles");
2589 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2590 strcat (buf, ", dsp");
55786da2
AK		 2591
2592 case EM_S390:
2593 if (e_flags & EF_S390_HIGH_GPRS)
2594 strcat (buf, ", highgprs");
40b36596
JM		 2595
2596 case EM_TI_C6000:
2597 if ((e_flags & EF_C6000_REL))
2598 strcat (buf, ", relocatable module");
252b5132
RH		 2599 }
2600 }
2601
2602 return buf;
2603}
2604
252b5132 2605static const char *
d3ba0551
AM		 2606get_osabi_name (unsigned int osabi)
2607{
2608 static char buff[32];
2609
2610 switch (osabi)
2611 {
2612 case ELFOSABI_NONE: return "UNIX - System V";
2613 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2614 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2615 case ELFOSABI_LINUX: return "UNIX - Linux";
2616 case ELFOSABI_HURD: return "GNU/Hurd";
2617 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2618 case ELFOSABI_AIX: return "UNIX - AIX";
2619 case ELFOSABI_IRIX: return "UNIX - IRIX";
2620 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2621 case ELFOSABI_TRU64: return "UNIX - TRU64";
2622 case ELFOSABI_MODESTO: return "Novell - Modesto";
2623 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2624 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2625 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2626 case ELFOSABI_AROS: return "AROS";
11636f9e 2627 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2628 default:
40b36596
JM		 2629 if (osabi >= 64)
2630 switch (elf_header.e_machine)
2631 {
2632 case EM_ARM:
2633 switch (osabi)
2634 {
2635 case ELFOSABI_ARM: return "ARM";
2636 default:
2637 break;
2638 }
2639 break;
2640
2641 case EM_MSP430:
2642 case EM_MSP430_OLD:
2643 switch (osabi)
2644 {
2645 case ELFOSABI_STANDALONE: return _("Standalone App");
2646 default:
2647 break;
2648 }
2649 break;
2650
2651 case EM_TI_C6000:
2652 switch (osabi)
2653 {
2654 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2655 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2656 default:
2657 break;
2658 }
2659 break;
2660
2661 default:
2662 break;
2663 }
e9e44622 2664 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2665 return buff;
2666 }
2667}
2668
b294bdf8
MM		 2669static const char *
2670get_arm_segment_type (unsigned long type)
2671{
2672 switch (type)
2673 {
2674 case PT_ARM_EXIDX:
2675 return "EXIDX";
2676 default:
2677 break;
2678 }
2679
2680 return NULL;
2681}
2682
d3ba0551
AM		 2683static const char *
2684get_mips_segment_type (unsigned long type)
252b5132
RH		 2685{
2686 switch (type)
2687 {
2688 case PT_MIPS_REGINFO:
2689 return "REGINFO";
2690 case PT_MIPS_RTPROC:
2691 return "RTPROC";
2692 case PT_MIPS_OPTIONS:
2693 return "OPTIONS";
2694 default:
2695 break;
2696 }
2697
2698 return NULL;
2699}
2700
103f02d3 2701static const char *
d3ba0551 2702get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2703{
2704 switch (type)
2705 {
2706 case PT_HP_TLS: return "HP_TLS";
2707 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2708 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2709 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2710 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2711 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2712 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2713 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2714 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2715 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2716 case PT_HP_PARALLEL: return "HP_PARALLEL";
2717 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2718 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2719 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2720 case PT_HP_STACK: return "HP_STACK";
2721 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2722 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2723 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2724 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2725 default:
2726 break;
2727 }
2728
2729 return NULL;
2730}
2731
4d6ed7c8 2732static const char *
d3ba0551 2733get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2734{
2735 switch (type)
2736 {
2737 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2738 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2739 case PT_HP_TLS: return "HP_TLS";
2740 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2741 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2742 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2743 default:
2744 break;
2745 }
2746
2747 return NULL;
2748}
2749
40b36596
JM		 2750static const char *
2751get_tic6x_segment_type (unsigned long type)
2752{
2753 switch (type)
2754 {
2755 case PT_C6000_PHATTR: return "C6000_PHATTR";
2756 default:
2757 break;
2758 }
2759
2760 return NULL;
2761}
2762
252b5132 2763static const char *
d3ba0551 2764get_segment_type (unsigned long p_type)
252b5132 2765{
b34976b6 2766 static char buff[32];
252b5132
RH		 2767
2768 switch (p_type)
2769 {
b34976b6
AM		 2770 case PT_NULL: return "NULL";
2771 case PT_LOAD: return "LOAD";
252b5132 2772 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2773 case PT_INTERP: return "INTERP";
2774 case PT_NOTE: return "NOTE";
2775 case PT_SHLIB: return "SHLIB";
2776 case PT_PHDR: return "PHDR";
13ae64f3 2777 case PT_TLS: return "TLS";
252b5132 2778
65765700
JJ		 2779 case PT_GNU_EH_FRAME:
2780 return "GNU_EH_FRAME";
2b05f1b7 2781 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2782 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2783
252b5132
RH		 2784 default:
2785 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2786 {
2cf0635d 2787 const char * result;
103f02d3 2788
252b5132
RH		 2789 switch (elf_header.e_machine)
2790 {
b294bdf8
MM		 2791 case EM_ARM:
2792 result = get_arm_segment_type (p_type);
2793 break;
252b5132 2794 case EM_MIPS:
4fe85591 2795 case EM_MIPS_RS3_LE:
252b5132
RH		 2796 result = get_mips_segment_type (p_type);
2797 break;
103f02d3
UD		 2798 case EM_PARISC:
2799 result = get_parisc_segment_type (p_type);
2800 break;
4d6ed7c8
NC		 2801 case EM_IA_64:
2802 result = get_ia64_segment_type (p_type);
2803 break;
40b36596
JM		 2804 case EM_TI_C6000:
2805 result = get_tic6x_segment_type (p_type);
2806 break;
252b5132
RH		 2807 default:
2808 result = NULL;
2809 break;
2810 }
103f02d3 2811
252b5132
RH		 2812 if (result != NULL)
2813 return result;
103f02d3 2814
252b5132
RH		 2815 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2816 }
2817 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2818 {
2cf0635d 2819 const char * result;
103f02d3
UD		 2820
2821 switch (elf_header.e_machine)
2822 {
2823 case EM_PARISC:
2824 result = get_parisc_segment_type (p_type);
2825 break;
00428cca
AM		 2826 case EM_IA_64:
2827 result = get_ia64_segment_type (p_type);
2828 break;
103f02d3
UD		 2829 default:
2830 result = NULL;
2831 break;
2832 }
2833
2834 if (result != NULL)
2835 return result;
2836
2837 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2838 }
252b5132 2839 else
e9e44622 2840 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2841
2842 return buff;
2843 }
2844}
2845
2846static const char *
d3ba0551 2847get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2848{
2849 switch (sh_type)
2850 {
b34976b6
AM		 2851 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2852 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2853 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2854 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2855 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2856 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2857 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2858 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2859 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2860 case SHT_MIPS_RELD: return "MIPS_RELD";
2861 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2862 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2863 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2864 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2865 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2866 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2867 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2868 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2869 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2870 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2871 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2872 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2873 case SHT_MIPS_LINE: return "MIPS_LINE";
2874 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2875 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2876 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2877 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2878 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2879 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2880 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2881 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2882 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2883 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2884 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2885 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2886 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2887 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2888 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2889 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2890 default:
2891 break;
2892 }
2893 return NULL;
2894}
2895
103f02d3 2896static const char *
d3ba0551 2897get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2898{
2899 switch (sh_type)
2900 {
2901 case SHT_PARISC_EXT: return "PARISC_EXT";
2902 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2903 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2904 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2905 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2906 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2907 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2908 default:
2909 break;
2910 }
2911 return NULL;
2912}
2913
4d6ed7c8 2914static const char *
d3ba0551 2915get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2916{
18bd398b 2917 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2918 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2919 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2920
4d6ed7c8
NC		 2921 switch (sh_type)
2922 {
148b93f2
NC		 2923 case SHT_IA_64_EXT: return "IA_64_EXT";
2924 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2925 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2926 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2927 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2928 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2929 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2930 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2931 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2932 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2933 default:
2934 break;
2935 }
2936 return NULL;
2937}
2938
d2b2c203
DJ		 2939static const char *
2940get_x86_64_section_type_name (unsigned int sh_type)
2941{
2942 switch (sh_type)
2943 {
2944 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2945 default:
2946 break;
2947 }
2948 return NULL;
2949}
2950
40a18ebd
NC		 2951static const char *
2952get_arm_section_type_name (unsigned int sh_type)
2953{
2954 switch (sh_type)
2955 {
7f6fed87
NC		 2956 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2957 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2958 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2959 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2960 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2961 default:
2962 break;
2963 }
2964 return NULL;
2965}
2966
40b36596
JM		 2967static const char *
2968get_tic6x_section_type_name (unsigned int sh_type)
2969{
2970 switch (sh_type)
2971 {
2972 case SHT_C6000_UNWIND:
2973 return "C6000_UNWIND";
2974 case SHT_C6000_PREEMPTMAP:
2975 return "C6000_PREEMPTMAP";
2976 case SHT_C6000_ATTRIBUTES:
2977 return "C6000_ATTRIBUTES";
2978 case SHT_TI_ICODE:
2979 return "TI_ICODE";
2980 case SHT_TI_XREF:
2981 return "TI_XREF";
2982 case SHT_TI_HANDLER:
2983 return "TI_HANDLER";
2984 case SHT_TI_INITINFO:
2985 return "TI_INITINFO";
2986 case SHT_TI_PHATTRS:
2987 return "TI_PHATTRS";
2988 default:
2989 break;
2990 }
2991 return NULL;
2992}
2993
252b5132 2994static const char *
d3ba0551 2995get_section_type_name (unsigned int sh_type)
252b5132 2996{
b34976b6 2997 static char buff[32];
252b5132
RH		 2998
2999 switch (sh_type)
3000 {
3001 case SHT_NULL: return "NULL";
3002 case SHT_PROGBITS: return "PROGBITS";
3003 case SHT_SYMTAB: return "SYMTAB";
3004 case SHT_STRTAB: return "STRTAB";
3005 case SHT_RELA: return "RELA";
3006 case SHT_HASH: return "HASH";
3007 case SHT_DYNAMIC: return "DYNAMIC";
3008 case SHT_NOTE: return "NOTE";
3009 case SHT_NOBITS: return "NOBITS";
3010 case SHT_REL: return "REL";
3011 case SHT_SHLIB: return "SHLIB";
3012 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3013 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3014 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3015 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3016 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3017 case SHT_GROUP: return "GROUP";
3018 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3019 case SHT_GNU_verdef: return "VERDEF";
3020 case SHT_GNU_verneed: return "VERNEED";
3021 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3022 case 0x6ffffff0: return "VERSYM";
3023 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3024 case 0x7ffffffd: return "AUXILIARY";
3025 case 0x7fffffff: return "FILTER";
047b2264 3026 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3027
3028 default:
3029 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3030 {
2cf0635d 3031 const char * result;
252b5132
RH		 3032
3033 switch (elf_header.e_machine)
3034 {
3035 case EM_MIPS:
4fe85591 3036 case EM_MIPS_RS3_LE:
252b5132
RH		 3037 result = get_mips_section_type_name (sh_type);
3038 break;
103f02d3
UD		 3039 case EM_PARISC:
3040 result = get_parisc_section_type_name (sh_type);
3041 break;
4d6ed7c8
NC		 3042 case EM_IA_64:
3043 result = get_ia64_section_type_name (sh_type);
3044 break;
d2b2c203 3045 case EM_X86_64:
8a9036a4 3046 case EM_L1OM:
d2b2c203
DJ		 3047 result = get_x86_64_section_type_name (sh_type);
3048 break;
40a18ebd
NC		 3049 case EM_ARM:
3050 result = get_arm_section_type_name (sh_type);
3051 break;
40b36596
JM		 3052 case EM_TI_C6000:
3053 result = get_tic6x_section_type_name (sh_type);
3054 break;
252b5132
RH		 3055 default:
3056 result = NULL;
3057 break;
3058 }
3059
3060 if (result != NULL)
3061 return result;
3062
c91d0dfb 3063 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3064 }
3065 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3066 {
2cf0635d 3067 const char * result;
148b93f2
NC		 3068
3069 switch (elf_header.e_machine)
3070 {
3071 case EM_IA_64:
3072 result = get_ia64_section_type_name (sh_type);
3073 break;
3074 default:
3075 result = NULL;
3076 break;
3077 }
3078
3079 if (result != NULL)
3080 return result;
3081
3082 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3083 }
252b5132 3084 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3085 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3086 else
a7dbfd1c
NC		 3087 /* This message is probably going to be displayed in a 15
3088 character wide field, so put the hex value first. */
3089 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3090
252b5132
RH		 3091 return buff;
3092 }
3093}
3094
2979dc34 3095#define OPTION_DEBUG_DUMP 512
2c610e4b 3096#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3097#define OPTION_DWARF_DEPTH 514
3098#define OPTION_DWARF_START 515
2979dc34 3099
85b1c36d 3100static struct option options[] =
252b5132 3101{
b34976b6 3102 {"all", no_argument, 0, 'a'},
252b5132
RH		 3103 {"file-header", no_argument, 0, 'h'},
3104 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3105 {"headers", no_argument, 0, 'e'},
3106 {"histogram", no_argument, 0, 'I'},
3107 {"segments", no_argument, 0, 'l'},
3108 {"sections", no_argument, 0, 'S'},
252b5132 3109 {"section-headers", no_argument, 0, 'S'},
f5842774 3110 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3111 {"section-details", no_argument, 0, 't'},
595cf52e 3112 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3113 {"symbols", no_argument, 0, 's'},
3114 {"syms", no_argument, 0, 's'},
2c610e4b 3115 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3116 {"relocs", no_argument, 0, 'r'},
3117 {"notes", no_argument, 0, 'n'},
3118 {"dynamic", no_argument, 0, 'd'},
a952a375 3119 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3120 {"version-info", no_argument, 0, 'V'},
3121 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3122 {"unwind", no_argument, 0, 'u'},
4145f1d5 3123 {"archive-index", no_argument, 0, 'c'},
b34976b6 3124 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3125 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3126 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3127#ifdef SUPPORT_DISASSEMBLY
3128 {"instruction-dump", required_argument, 0, 'i'},
3129#endif
cf13d699 3130 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3131
fd2f0033
TT		 3132 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3133 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3134
b34976b6
AM		 3135 {"version", no_argument, 0, 'v'},
3136 {"wide", no_argument, 0, 'W'},
3137 {"help", no_argument, 0, 'H'},
3138 {0, no_argument, 0, 0}
252b5132
RH		 3139};
3140
3141static void
2cf0635d 3142usage (FILE * stream)
252b5132 3143{
92f01d61
JM		 3144 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3145 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3146 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3147 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3148 -h --file-header Display the ELF file header\n\
3149 -l --program-headers Display the program headers\n\
3150 --segments An alias for --program-headers\n\
3151 -S --section-headers Display the sections' header\n\
3152 --sections An alias for --section-headers\n\
f5842774 3153 -g --section-groups Display the section groups\n\
5477e8a0 3154 -t --section-details Display the section details\n\
8b53311e
NC		 3155 -e --headers Equivalent to: -h -l -S\n\
3156 -s --syms Display the symbol table\n\
3f08eb35 3157 --symbols An alias for --syms\n\
2c610e4b 3158 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3159 -n --notes Display the core notes (if present)\n\
3160 -r --relocs Display the relocations (if present)\n\
3161 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3162 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3163 -V --version-info Display the version sections (if present)\n\
3164 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3165 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3166 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3167 -x --hex-dump=<number|name>\n\
3168 Dump the contents of section <number|name> as bytes\n\
3169 -p --string-dump=<number|name>\n\
3170 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3171 -R --relocated-dump=<number|name>\n\
3172 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3173 -w[lLiaprmfFsoRt] or\n\
1ed06042 3174 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3175 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3176 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3177 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3178 fprintf (stream, _("\
3179 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3180 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3181 or deeper\n"));
252b5132 3182#ifdef SUPPORT_DISASSEMBLY
92f01d61 3183 fprintf (stream, _("\
09c11c86
NC		 3184 -i --instruction-dump=<number|name>\n\
3185 Disassemble the contents of section <number|name>\n"));
252b5132 3186#endif
92f01d61 3187 fprintf (stream, _("\
8b53311e
NC		 3188 -I --histogram Display histogram of bucket list lengths\n\
3189 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3190 @<file> Read options from <file>\n\
8b53311e
NC		 3191 -H --help Display this information\n\
3192 -v --version Display the version number of readelf\n"));
1118d252 3193
92f01d61
JM		 3194 if (REPORT_BUGS_TO[0] && stream == stdout)
3195 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3196
92f01d61 3197 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3198}
3199
18bd398b
NC		 3200/* Record the fact that the user wants the contents of section number
3201 SECTION to be displayed using the method(s) encoded as flags bits
3202 in TYPE. Note, TYPE can be zero if we are creating the array for
3203 the first time. */
3204
252b5132 3205static void
09c11c86 3206request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3207{
3208 if (section >= num_dump_sects)
3209 {
2cf0635d 3210 dump_type * new_dump_sects;
252b5132 3211
3f5e193b
NC		 3212 new_dump_sects = (dump_type *) calloc (section + 1,
3213 sizeof (* dump_sects));
252b5132
RH		 3214
3215 if (new_dump_sects == NULL)
591a748a 3216 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3217 else
3218 {
3219 /* Copy current flag settings. */
09c11c86 3220 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3221
3222 free (dump_sects);
3223
3224 dump_sects = new_dump_sects;
3225 num_dump_sects = section + 1;
3226 }
3227 }
3228
3229 if (dump_sects)
b34976b6 3230 dump_sects[section] |= type;
252b5132
RH		 3231
3232 return;
3233}
3234
aef1f6d0
DJ		 3235/* Request a dump by section name. */
3236
3237static void
2cf0635d 3238request_dump_byname (const char * section, dump_type type)
aef1f6d0 3239{
2cf0635d 3240 struct dump_list_entry * new_request;
aef1f6d0 3241
3f5e193b
NC		 3242 new_request = (struct dump_list_entry *)
3243 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3244 if (!new_request)
591a748a 3245 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3246
3247 new_request->name = strdup (section);
3248 if (!new_request->name)
591a748a 3249 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3250
3251 new_request->type = type;
3252
3253 new_request->next = dump_sects_byname;
3254 dump_sects_byname = new_request;
3255}
3256
cf13d699
NC		 3257static inline void
3258request_dump (dump_type type)
3259{
3260 int section;
3261 char * cp;
3262
3263 do_dump++;
3264 section = strtoul (optarg, & cp, 0);
3265
3266 if (! *cp && section >= 0)
3267 request_dump_bynumber (section, type);
3268 else
3269 request_dump_byname (optarg, type);
3270}
3271
3272
252b5132 3273static void
2cf0635d 3274parse_args (int argc, char ** argv)
252b5132
RH		 3275{
3276 int c;
3277
3278 if (argc < 2)
92f01d61 3279 usage (stderr);
252b5132
RH		 3280
3281 while ((c = getopt_long
cf13d699 3282 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3283 {
252b5132
RH		 3284 switch (c)
3285 {
3286 case 0:
3287 /* Long options. */
3288 break;
3289 case 'H':
92f01d61 3290 usage (stdout);
252b5132
RH		 3291 break;
3292
3293 case 'a':
b34976b6
AM		 3294 do_syms++;
3295 do_reloc++;
3296 do_unwind++;
3297 do_dynamic++;
3298 do_header++;
3299 do_sections++;
f5842774 3300 do_section_groups++;
b34976b6
AM		 3301 do_segments++;
3302 do_version++;
3303 do_histogram++;
3304 do_arch++;
3305 do_notes++;
252b5132 3306 break;
f5842774
L		 3307 case 'g':
3308 do_section_groups++;
3309 break;
5477e8a0 3310 case 't':
595cf52e 3311 case 'N':
5477e8a0
L		 3312 do_sections++;
3313 do_section_details++;
595cf52e 3314 break;
252b5132 3315 case 'e':
b34976b6
AM		 3316 do_header++;
3317 do_sections++;
3318 do_segments++;
252b5132 3319 break;
a952a375 3320 case 'A':
b34976b6 3321 do_arch++;
a952a375 3322 break;
252b5132 3323 case 'D':
b34976b6 3324 do_using_dynamic++;
252b5132
RH		 3325 break;
3326 case 'r':
b34976b6 3327 do_reloc++;
252b5132 3328 break;
4d6ed7c8 3329 case 'u':
b34976b6 3330 do_unwind++;
4d6ed7c8 3331 break;
252b5132 3332 case 'h':
b34976b6 3333 do_header++;
252b5132
RH		 3334 break;
3335 case 'l':
b34976b6 3336 do_segments++;
252b5132
RH		 3337 break;
3338 case 's':
b34976b6 3339 do_syms++;
252b5132
RH		 3340 break;
3341 case 'S':
b34976b6 3342 do_sections++;
252b5132
RH		 3343 break;
3344 case 'd':
b34976b6 3345 do_dynamic++;
252b5132 3346 break;
a952a375 3347 case 'I':
b34976b6 3348 do_histogram++;
a952a375 3349 break;
779fe533 3350 case 'n':
b34976b6 3351 do_notes++;
779fe533 3352 break;
4145f1d5
NC		 3353 case 'c':
3354 do_archive_index++;
3355 break;
252b5132 3356 case 'x':
cf13d699 3357 request_dump (HEX_DUMP);
aef1f6d0 3358 break;
09c11c86 3359 case 'p':
cf13d699
NC		 3360 request_dump (STRING_DUMP);
3361 break;
3362 case 'R':
3363 request_dump (RELOC_DUMP);
09c11c86 3364 break;
252b5132 3365 case 'w':
b34976b6 3366 do_dump++;
252b5132 3367 if (optarg == 0)
613ff48b
CC		 3368 {
3369 do_debugging = 1;
3370 dwarf_select_sections_all ();
3371 }
252b5132
RH		 3372 else
3373 {
3374 do_debugging = 0;
4cb93e3b 3375 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3376 }
3377 break;
2979dc34 3378 case OPTION_DEBUG_DUMP:
b34976b6 3379 do_dump++;
2979dc34
JJ		 3380 if (optarg == 0)
3381 do_debugging = 1;
3382 else
3383 {
2979dc34 3384 do_debugging = 0;
4cb93e3b 3385 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3386 }
3387 break;
fd2f0033
TT		 3388 case OPTION_DWARF_DEPTH:
3389 {
3390 char *cp;
3391
3392 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3393 }
3394 break;
3395 case OPTION_DWARF_START:
3396 {
3397 char *cp;
3398
3399 dwarf_start_die = strtoul (optarg, & cp, 0);
3400 }
3401 break;
2c610e4b
L		 3402 case OPTION_DYN_SYMS:
3403 do_dyn_syms++;
3404 break;
252b5132
RH		 3405#ifdef SUPPORT_DISASSEMBLY
3406 case 'i':
cf13d699
NC		 3407 request_dump (DISASS_DUMP);
3408 break;
252b5132
RH		 3409#endif
3410 case 'v':
3411 print_version (program_name);
3412 break;
3413 case 'V':
b34976b6 3414 do_version++;
252b5132 3415 break;
d974e256 3416 case 'W':
b34976b6 3417 do_wide++;
d974e256 3418 break;
252b5132 3419 default:
252b5132
RH		 3420 /* xgettext:c-format */
3421 error (_("Invalid option '-%c'\n"), c);
3422 /* Drop through. */
3423 case '?':
92f01d61 3424 usage (stderr);
252b5132
RH		 3425 }
3426 }
3427
4d6ed7c8 3428 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3429 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3430 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3431 && !do_section_groups && !do_archive_index
3432 && !do_dyn_syms)
92f01d61 3433 usage (stderr);
252b5132
RH		 3434 else if (argc < 3)
3435 {
3436 warn (_("Nothing to do.\n"));
92f01d61 3437 usage (stderr);
252b5132
RH		 3438 }
3439}
3440
3441static const char *
d3ba0551 3442get_elf_class (unsigned int elf_class)
252b5132 3443{
b34976b6 3444 static char buff[32];
103f02d3 3445
252b5132
RH		 3446 switch (elf_class)
3447 {
3448 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3449 case ELFCLASS32: return "ELF32";
3450 case ELFCLASS64: return "ELF64";
ab5e7794 3451 default:
e9e44622 3452 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3453 return buff;
252b5132
RH		 3454 }
3455}
3456
3457static const char *
d3ba0551 3458get_data_encoding (unsigned int encoding)
252b5132 3459{
b34976b6 3460 static char buff[32];
103f02d3 3461
252b5132
RH		 3462 switch (encoding)
3463 {
3464 case ELFDATANONE: return _("none");
33c63f9d
CM		 3465 case ELFDATA2LSB: return _("2's complement, little endian");
3466 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3467 default:
e9e44622 3468 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3469 return buff;
252b5132
RH		 3470 }
3471}
3472
252b5132 3473/* Decode the data held in 'elf_header'. */
ee42cf8c 3474
252b5132 3475static int
d3ba0551 3476process_file_header (void)
252b5132 3477{
b34976b6
AM		 3478 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3479 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3480 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3481 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3482 {
3483 error
3484 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3485 return 0;
3486 }
3487
2dc4cec1
L		 3488 init_dwarf_regnames (elf_header.e_machine);
3489
252b5132
RH		 3490 if (do_header)
3491 {
3492 int i;
3493
3494 printf (_("ELF Header:\n"));
3495 printf (_(" Magic: "));
b34976b6
AM		 3496 for (i = 0; i < EI_NIDENT; i++)
3497 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3498 printf ("\n");
3499 printf (_(" Class: %s\n"),
b34976b6 3500 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3501 printf (_(" Data: %s\n"),
b34976b6 3502 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3503 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3504 elf_header.e_ident[EI_VERSION],
3505 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3506 ? "(current)"
b34976b6 3507 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3508 ? _("<unknown: %lx>")
789be9f7 3509 : "")));
252b5132 3510 printf (_(" OS/ABI: %s\n"),
b34976b6 3511 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3512 printf (_(" ABI Version: %d\n"),
b34976b6 3513 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3514 printf (_(" Type: %s\n"),
3515 get_file_type (elf_header.e_type));
3516 printf (_(" Machine: %s\n"),
3517 get_machine_name (elf_header.e_machine));
3518 printf (_(" Version: 0x%lx\n"),
3519 (unsigned long) elf_header.e_version);
76da6bbe 3520
f7a99963
NC		 3521 printf (_(" Entry point address: "));
3522 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3523 printf (_("\n Start of program headers: "));
3524 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3525 printf (_(" (bytes into file)\n Start of section headers: "));
3526 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3527 printf (_(" (bytes into file)\n"));
76da6bbe 3528
252b5132
RH		 3529 printf (_(" Flags: 0x%lx%s\n"),
3530 (unsigned long) elf_header.e_flags,
3531 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3532 printf (_(" Size of this header: %ld (bytes)\n"),
3533 (long) elf_header.e_ehsize);
3534 printf (_(" Size of program headers: %ld (bytes)\n"),
3535 (long) elf_header.e_phentsize);
2046a35d 3536 printf (_(" Number of program headers: %ld"),
252b5132 3537 (long) elf_header.e_phnum);
2046a35d
AM		 3538 if (section_headers != NULL
3539 && elf_header.e_phnum == PN_XNUM
3540 && section_headers[0].sh_info != 0)
cc5914eb 3541 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3542 putc ('\n', stdout);
252b5132
RH		 3543 printf (_(" Size of section headers: %ld (bytes)\n"),
3544 (long) elf_header.e_shentsize);
560f3c1c 3545 printf (_(" Number of section headers: %ld"),
252b5132 3546 (long) elf_header.e_shnum);
4fbb74a6 3547 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3548 printf (" (%ld)", (long) section_headers[0].sh_size);
3549 putc ('\n', stdout);
3550 printf (_(" Section header string table index: %ld"),
252b5132 3551 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3552 if (section_headers != NULL
3553 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3554 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3555 else if (elf_header.e_shstrndx != SHN_UNDEF
3556 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3557 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3558 putc ('\n', stdout);
3559 }
3560
3561 if (section_headers != NULL)
3562 {
2046a35d
AM		 3563 if (elf_header.e_phnum == PN_XNUM
3564 && section_headers[0].sh_info != 0)
3565 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3566 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3567 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3568 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3569 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3570 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3571 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3572 free (section_headers);
3573 section_headers = NULL;
252b5132 3574 }
103f02d3 3575
9ea033b2
NC		 3576 return 1;
3577}
3578
252b5132 3579
9ea033b2 3580static int
91d6fa6a 3581get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3582{
2cf0635d
NC		 3583 Elf32_External_Phdr * phdrs;
3584 Elf32_External_Phdr * external;
3585 Elf_Internal_Phdr * internal;
b34976b6 3586 unsigned int i;
103f02d3 3587
3f5e193b
NC		 3588 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3589 elf_header.e_phentsize,
3590 elf_header.e_phnum,
3591 _("program headers"));
a6e9f9df
AM		 3592 if (!phdrs)
3593 return 0;
9ea033b2 3594
91d6fa6a 3595 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3596 i < elf_header.e_phnum;
b34976b6 3597 i++, internal++, external++)
252b5132 3598 {
9ea033b2
NC		 3599 internal->p_type = BYTE_GET (external->p_type);
3600 internal->p_offset = BYTE_GET (external->p_offset);
3601 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3602 internal->p_paddr = BYTE_GET (external->p_paddr);
3603 internal->p_filesz = BYTE_GET (external->p_filesz);
3604 internal->p_memsz = BYTE_GET (external->p_memsz);
3605 internal->p_flags = BYTE_GET (external->p_flags);
3606 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3607 }
3608
9ea033b2
NC		 3609 free (phdrs);
3610
252b5132
RH		 3611 return 1;
3612}
3613
9ea033b2 3614static int
91d6fa6a 3615get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3616{
2cf0635d
NC		 3617 Elf64_External_Phdr * phdrs;
3618 Elf64_External_Phdr * external;
3619 Elf_Internal_Phdr * internal;
b34976b6 3620 unsigned int i;
103f02d3 3621
3f5e193b
NC		 3622 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3623 elf_header.e_phentsize,
3624 elf_header.e_phnum,
3625 _("program headers"));
a6e9f9df
AM		 3626 if (!phdrs)
3627 return 0;
9ea033b2 3628
91d6fa6a 3629 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3630 i < elf_header.e_phnum;
b34976b6 3631 i++, internal++, external++)
9ea033b2
NC		 3632 {
3633 internal->p_type = BYTE_GET (external->p_type);
3634 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3635 internal->p_offset = BYTE_GET (external->p_offset);
3636 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3637 internal->p_paddr = BYTE_GET (external->p_paddr);
3638 internal->p_filesz = BYTE_GET (external->p_filesz);
3639 internal->p_memsz = BYTE_GET (external->p_memsz);
3640 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3641 }
3642
3643 free (phdrs);
3644
3645 return 1;
3646}
252b5132 3647
d93f0186
NC		 3648/* Returns 1 if the program headers were read into `program_headers'. */
3649
3650static int
2cf0635d 3651get_program_headers (FILE * file)
d93f0186 3652{
2cf0635d 3653 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3654
3655 /* Check cache of prior read. */
3656 if (program_headers != NULL)
3657 return 1;
3658
3f5e193b
NC		 3659 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3660 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3661
3662 if (phdrs == NULL)
3663 {
3664 error (_("Out of memory\n"));
3665 return 0;
3666 }
3667
3668 if (is_32bit_elf
3669 ? get_32bit_program_headers (file, phdrs)
3670 : get_64bit_program_headers (file, phdrs))
3671 {
3672 program_headers = phdrs;
3673 return 1;
3674 }
3675
3676 free (phdrs);
3677 return 0;
3678}
3679
2f62977e
NC		 3680/* Returns 1 if the program headers were loaded. */
3681
252b5132 3682static int
2cf0635d 3683process_program_headers (FILE * file)
252b5132 3684{
2cf0635d 3685 Elf_Internal_Phdr * segment;
b34976b6 3686 unsigned int i;
252b5132
RH		 3687
3688 if (elf_header.e_phnum == 0)
3689 {
82f2dbf7
NC		 3690 /* PR binutils/12467. */
3691 if (elf_header.e_phoff != 0)
3692 warn (_("possibly corrupt ELF header - it has a non-zero program"
3693 " header offset, but no program headers"));
3694 else if (do_segments)
252b5132 3695 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3696 return 0;
252b5132
RH		 3697 }
3698
3699 if (do_segments && !do_header)
3700 {
f7a99963
NC		 3701 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3702 printf (_("Entry point "));
3703 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3704 printf (_("\nThere are %d program headers, starting at offset "),
3705 elf_header.e_phnum);
3706 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3707 printf ("\n");
252b5132
RH		 3708 }
3709
d93f0186 3710 if (! get_program_headers (file))
252b5132 3711 return 0;
103f02d3 3712
252b5132
RH		 3713 if (do_segments)
3714 {
3a1a2036
NC		 3715 if (elf_header.e_phnum > 1)
3716 printf (_("\nProgram Headers:\n"));
3717 else
3718 printf (_("\nProgram Headers:\n"));
76da6bbe 3719
f7a99963
NC		 3720 if (is_32bit_elf)
3721 printf
3722 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3723 else if (do_wide)
3724 printf
3725 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3726 else
3727 {
3728 printf
3729 (_(" Type Offset VirtAddr PhysAddr\n"));
3730 printf
3731 (_(" FileSiz MemSiz Flags Align\n"));
3732 }
252b5132
RH		 3733 }
3734
252b5132 3735 dynamic_addr = 0;
1b228002 3736 dynamic_size = 0;
252b5132
RH		 3737
3738 for (i = 0, segment = program_headers;
3739 i < elf_header.e_phnum;
b34976b6 3740 i++, segment++)
252b5132
RH		 3741 {
3742 if (do_segments)
3743 {
103f02d3 3744 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3745
3746 if (is_32bit_elf)
3747 {
3748 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3749 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3750 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3751 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3752 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3753 printf ("%c%c%c ",
3754 (segment->p_flags & PF_R ? 'R' : ' '),
3755 (segment->p_flags & PF_W ? 'W' : ' '),
3756 (segment->p_flags & PF_X ? 'E' : ' '));
3757 printf ("%#lx", (unsigned long) segment->p_align);
3758 }
d974e256
JJ		 3759 else if (do_wide)
3760 {
3761 if ((unsigned long) segment->p_offset == segment->p_offset)
3762 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3763 else
3764 {
3765 print_vma (segment->p_offset, FULL_HEX);
3766 putchar (' ');
3767 }
3768
3769 print_vma (segment->p_vaddr, FULL_HEX);
3770 putchar (' ');
3771 print_vma (segment->p_paddr, FULL_HEX);
3772 putchar (' ');
3773
3774 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3775 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3776 else
3777 {
3778 print_vma (segment->p_filesz, FULL_HEX);
3779 putchar (' ');
3780 }
3781
3782 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3783 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3784 else
3785 {
3786 print_vma (segment->p_offset, FULL_HEX);
3787 }
3788
3789 printf (" %c%c%c ",
3790 (segment->p_flags & PF_R ? 'R' : ' '),
3791 (segment->p_flags & PF_W ? 'W' : ' '),
3792 (segment->p_flags & PF_X ? 'E' : ' '));
3793
3794 if ((unsigned long) segment->p_align == segment->p_align)
3795 printf ("%#lx", (unsigned long) segment->p_align);
3796 else
3797 {
3798 print_vma (segment->p_align, PREFIX_HEX);
3799 }
3800 }
f7a99963
NC		 3801 else
3802 {
3803 print_vma (segment->p_offset, FULL_HEX);
3804 putchar (' ');
3805 print_vma (segment->p_vaddr, FULL_HEX);
3806 putchar (' ');
3807 print_vma (segment->p_paddr, FULL_HEX);
3808 printf ("\n ");
3809 print_vma (segment->p_filesz, FULL_HEX);
3810 putchar (' ');
3811 print_vma (segment->p_memsz, FULL_HEX);
3812 printf (" %c%c%c ",
3813 (segment->p_flags & PF_R ? 'R' : ' '),
3814 (segment->p_flags & PF_W ? 'W' : ' '),
3815 (segment->p_flags & PF_X ? 'E' : ' '));
3816 print_vma (segment->p_align, HEX);
3817 }
252b5132
RH		 3818 }
3819
3820 switch (segment->p_type)
3821 {
252b5132
RH		 3822 case PT_DYNAMIC:
3823 if (dynamic_addr)
3824 error (_("more than one dynamic segment\n"));
3825
20737c13
AM		 3826 /* By default, assume that the .dynamic section is the first
3827 section in the DYNAMIC segment. */
3828 dynamic_addr = segment->p_offset;
3829 dynamic_size = segment->p_filesz;
3830
b2d38a17
NC		 3831 /* Try to locate the .dynamic section. If there is
3832 a section header table, we can easily locate it. */
3833 if (section_headers != NULL)
3834 {
2cf0635d 3835 Elf_Internal_Shdr * sec;
b2d38a17 3836
89fac5e3
RS		 3837 sec = find_section (".dynamic");
3838 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3839 {
28f997cf
TG		 3840 /* A corresponding .dynamic section is expected, but on
3841 IA-64/OpenVMS it is OK for it to be missing. */
3842 if (!is_ia64_vms ())
3843 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3844 break;
3845 }
3846
42bb2e33 3847 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3848 {
3849 dynamic_size = 0;
3850 break;
3851 }
42bb2e33 3852
b2d38a17
NC		 3853 dynamic_addr = sec->sh_offset;
3854 dynamic_size = sec->sh_size;
3855
3856 if (dynamic_addr < segment->p_offset
3857 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3858 warn (_("the .dynamic section is not contained"
3859 " within the dynamic segment\n"));
b2d38a17 3860 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3861 warn (_("the .dynamic section is not the first section"
3862 " in the dynamic segment.\n"));
b2d38a17 3863 }
252b5132
RH		 3864 break;
3865
3866 case PT_INTERP:
fb52b2f4
NC		 3867 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3868 SEEK_SET))
252b5132
RH		 3869 error (_("Unable to find program interpreter name\n"));
3870 else
3871 {
f8eae8b2
L		 3872 char fmt [32];
3873 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3874
3875 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3876 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3877
252b5132 3878 program_interpreter[0] = 0;
7bd7b3ef
AM		 3879 if (fscanf (file, fmt, program_interpreter) <= 0)
3880 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3881
3882 if (do_segments)
3883 printf (_("\n [Requesting program interpreter: %s]"),
3884 program_interpreter);
3885 }
3886 break;
3887 }
3888
3889 if (do_segments)
3890 putc ('\n', stdout);
3891 }
3892
c256ffe7 3893 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3894 {
3895 printf (_("\n Section to Segment mapping:\n"));
3896 printf (_(" Segment Sections...\n"));
3897
252b5132
RH		 3898 for (i = 0; i < elf_header.e_phnum; i++)
3899 {
9ad5cbcf 3900 unsigned int j;
2cf0635d 3901 Elf_Internal_Shdr * section;
252b5132
RH		 3902
3903 segment = program_headers + i;
b391a3e3 3904 section = section_headers + 1;
252b5132
RH		 3905
3906 printf (" %2.2d ", i);
3907
b34976b6 3908 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3909 {
f4638467
AM		 3910 if (!ELF_TBSS_SPECIAL (section, segment)
3911 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3912 printf ("%s ", SECTION_NAME (section));
3913 }
3914
3915 putc ('\n',stdout);
3916 }
3917 }
3918
252b5132
RH		 3919 return 1;
3920}
3921
3922
d93f0186
NC		 3923/* Find the file offset corresponding to VMA by using the program headers. */
3924
3925static long
2cf0635d 3926offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3927{
2cf0635d 3928 Elf_Internal_Phdr * seg;
d93f0186
NC		 3929
3930 if (! get_program_headers (file))
3931 {
3932 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3933 return (long) vma;
3934 }
3935
3936 for (seg = program_headers;
3937 seg < program_headers + elf_header.e_phnum;
3938 ++seg)
3939 {
3940 if (seg->p_type != PT_LOAD)
3941 continue;
3942
3943 if (vma >= (seg->p_vaddr & -seg->p_align)
3944 && vma + size <= seg->p_vaddr + seg->p_filesz)
3945 return vma - seg->p_vaddr + seg->p_offset;
3946 }
3947
3948 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3949 (unsigned long) vma);
d93f0186
NC		 3950 return (long) vma;
3951}
3952
3953
252b5132 3954static int
2cf0635d 3955get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3956{
2cf0635d
NC		 3957 Elf32_External_Shdr * shdrs;
3958 Elf_Internal_Shdr * internal;
b34976b6 3959 unsigned int i;
252b5132 3960
3f5e193b
NC		 3961 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3962 elf_header.e_shentsize, num,
3963 _("section headers"));
a6e9f9df
AM		 3964 if (!shdrs)
3965 return 0;
252b5132 3966
3f5e193b
NC		 3967 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3968 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3969
3970 if (section_headers == NULL)
3971 {
3972 error (_("Out of memory\n"));
3973 return 0;
3974 }
3975
3976 for (i = 0, internal = section_headers;
560f3c1c 3977 i < num;
b34976b6 3978 i++, internal++)
252b5132
RH		 3979 {
3980 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3981 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3982 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3983 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3984 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3985 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3986 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3987 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3988 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3989 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3990 }
3991
3992 free (shdrs);
3993
3994 return 1;
3995}
3996
9ea033b2 3997static int
2cf0635d 3998get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 3999{
2cf0635d
NC		 4000 Elf64_External_Shdr * shdrs;
4001 Elf_Internal_Shdr * internal;
b34976b6 4002 unsigned int i;
9ea033b2 4003
3f5e193b
NC		 4004 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4005 elf_header.e_shentsize, num,
4006 _("section headers"));
a6e9f9df
AM		 4007 if (!shdrs)
4008 return 0;
9ea033b2 4009
3f5e193b
NC		 4010 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4011 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4012
4013 if (section_headers == NULL)
4014 {
4015 error (_("Out of memory\n"));
4016 return 0;
4017 }
4018
4019 for (i = 0, internal = section_headers;
560f3c1c 4020 i < num;
b34976b6 4021 i++, internal++)
9ea033b2
NC		 4022 {
4023 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4024 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4025 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4026 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4027 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4028 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4029 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4030 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4031 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4032 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4033 }
4034
4035 free (shdrs);
4036
4037 return 1;
4038}
4039
252b5132 4040static Elf_Internal_Sym *
2cf0635d 4041get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 4042{
9ad5cbcf 4043 unsigned long number;
dd24e3da 4044 Elf32_External_Sym * esyms = NULL;
2cf0635d 4045 Elf_External_Sym_Shndx * shndx;
dd24e3da 4046 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4047 Elf_Internal_Sym * psym;
b34976b6 4048 unsigned int j;
252b5132 4049
dd24e3da
NC		 4050 /* Run some sanity checks first. */
4051 if (section->sh_entsize == 0)
4052 {
4053 error (_("sh_entsize is zero\n"));
4054 return NULL;
4055 }
4056
4057 number = section->sh_size / section->sh_entsize;
4058
4059 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4060 {
4061 error (_("Invalid sh_entsize\n"));
4062 return NULL;
4063 }
4064
3f5e193b
NC		 4065 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4066 section->sh_size, _("symbols"));
dd24e3da 4067 if (esyms == NULL)
a6e9f9df 4068 return NULL;
252b5132 4069
9ad5cbcf
AM		 4070 shndx = NULL;
4071 if (symtab_shndx_hdr != NULL
4072 && (symtab_shndx_hdr->sh_link
4fbb74a6 4073 == (unsigned long) (section - section_headers)))
9ad5cbcf 4074 {
3f5e193b
NC		 4075 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4076 symtab_shndx_hdr->sh_offset,
4077 1, symtab_shndx_hdr->sh_size,
4078 _("symtab shndx"));
dd24e3da
NC		 4079 if (shndx == NULL)
4080 goto exit_point;
9ad5cbcf
AM		 4081 }
4082
3f5e193b 4083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4084
4085 if (isyms == NULL)
4086 {
4087 error (_("Out of memory\n"));
dd24e3da 4088 goto exit_point;
252b5132
RH		 4089 }
4090
dd24e3da 4091 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4092 {
4093 psym->st_name = BYTE_GET (esyms[j].st_name);
4094 psym->st_value = BYTE_GET (esyms[j].st_value);
4095 psym->st_size = BYTE_GET (esyms[j].st_size);
4096 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4097 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4098 psym->st_shndx
4099 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4100 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4101 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4102 psym->st_info = BYTE_GET (esyms[j].st_info);
4103 psym->st_other = BYTE_GET (esyms[j].st_other);
4104 }
4105
dd24e3da 4106 exit_point:
9ad5cbcf
AM		 4107 if (shndx)
4108 free (shndx);
dd24e3da
NC		 4109 if (esyms)
4110 free (esyms);
252b5132
RH		 4111
4112 return isyms;
4113}
4114
9ea033b2 4115static Elf_Internal_Sym *
2cf0635d 4116get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4117{
9ad5cbcf 4118 unsigned long number;
2cf0635d
NC		 4119 Elf64_External_Sym * esyms;
4120 Elf_External_Sym_Shndx * shndx;
4121 Elf_Internal_Sym * isyms;
4122 Elf_Internal_Sym * psym;
b34976b6 4123 unsigned int j;
9ea033b2 4124
dd24e3da
NC		 4125 /* Run some sanity checks first. */
4126 if (section->sh_entsize == 0)
4127 {
4128 error (_("sh_entsize is zero\n"));
4129 return NULL;
4130 }
4131
4132 number = section->sh_size / section->sh_entsize;
4133
4134 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4135 {
4136 error (_("Invalid sh_entsize\n"));
4137 return NULL;
4138 }
4139
3f5e193b
NC		 4140 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4141 section->sh_size, _("symbols"));
a6e9f9df
AM		 4142 if (!esyms)
4143 return NULL;
9ea033b2 4144
9ad5cbcf
AM		 4145 shndx = NULL;
4146 if (symtab_shndx_hdr != NULL
4147 && (symtab_shndx_hdr->sh_link
4fbb74a6 4148 == (unsigned long) (section - section_headers)))
9ad5cbcf 4149 {
3f5e193b
NC		 4150 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4151 symtab_shndx_hdr->sh_offset,
4152 1, symtab_shndx_hdr->sh_size,
4153 _("symtab shndx"));
9ad5cbcf
AM		 4154 if (!shndx)
4155 {
4156 free (esyms);
4157 return NULL;
4158 }
4159 }
4160
3f5e193b 4161 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4162
4163 if (isyms == NULL)
4164 {
4165 error (_("Out of memory\n"));
9ad5cbcf
AM		 4166 if (shndx)
4167 free (shndx);
9ea033b2 4168 free (esyms);
9ea033b2
NC		 4169 return NULL;
4170 }
4171
4172 for (j = 0, psym = isyms;
4173 j < number;
b34976b6 4174 j++, psym++)
9ea033b2
NC		 4175 {
4176 psym->st_name = BYTE_GET (esyms[j].st_name);
4177 psym->st_info = BYTE_GET (esyms[j].st_info);
4178 psym->st_other = BYTE_GET (esyms[j].st_other);
4179 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4180 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4181 psym->st_shndx
4182 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4183 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4184 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4185 psym->st_value = BYTE_GET (esyms[j].st_value);
4186 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4187 }
4188
9ad5cbcf
AM		 4189 if (shndx)
4190 free (shndx);
9ea033b2
NC		 4191 free (esyms);
4192
4193 return isyms;
4194}
4195
d1133906 4196static const char *
d3ba0551 4197get_elf_section_flags (bfd_vma sh_flags)
d1133906 4198{
5477e8a0 4199 static char buff[1024];
2cf0635d 4200 char * p = buff;
8d5ff12c 4201 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4202 int sindex;
4203 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4204 bfd_vma os_flags = 0;
4205 bfd_vma proc_flags = 0;
4206 bfd_vma unknown_flags = 0;
148b93f2 4207 static const struct
5477e8a0 4208 {
2cf0635d 4209 const char * str;
5477e8a0
L		 4210 int len;
4211 }
4212 flags [] =
4213 {
cfcac11d
NC		 4214 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4215 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4216 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4217 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4218 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4219 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4220 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4221 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4222 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4223 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4224 /* IA-64 specific. */
4225 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4226 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4227 /* IA-64 OpenVMS specific. */
4228 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4229 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4230 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4231 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4232 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4233 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4234 /* Generic. */
cfcac11d 4235 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4236 /* SPARC specific. */
cfcac11d 4237 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4238 };
4239
4240 if (do_section_details)
4241 {
8d5ff12c
L		 4242 sprintf (buff, "[%*.*lx]: ",
4243 field_size, field_size, (unsigned long) sh_flags);
4244 p += field_size + 4;
5477e8a0 4245 }
76da6bbe 4246
d1133906
NC		 4247 while (sh_flags)
4248 {
4249 bfd_vma flag;
4250
4251 flag = sh_flags & - sh_flags;
4252 sh_flags &= ~ flag;
76da6bbe 4253
5477e8a0 4254 if (do_section_details)
d1133906 4255 {
5477e8a0
L		 4256 switch (flag)
4257 {
91d6fa6a
NC		 4258 case SHF_WRITE: sindex = 0; break;
4259 case SHF_ALLOC: sindex = 1; break;
4260 case SHF_EXECINSTR: sindex = 2; break;
4261 case SHF_MERGE: sindex = 3; break;
4262 case SHF_STRINGS: sindex = 4; break;
4263 case SHF_INFO_LINK: sindex = 5; break;
4264 case SHF_LINK_ORDER: sindex = 6; break;
4265 case SHF_OS_NONCONFORMING: sindex = 7; break;
4266 case SHF_GROUP: sindex = 8; break;
4267 case SHF_TLS: sindex = 9; break;
18ae9cc1 4268 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4269
5477e8a0 4270 default:
91d6fa6a 4271 sindex = -1;
cfcac11d 4272 switch (elf_header.e_machine)
148b93f2 4273 {
cfcac11d 4274 case EM_IA_64:
148b93f2 4275 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4276 sindex = 10;
148b93f2 4277 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4278 sindex = 11;
148b93f2
NC		 4279#ifdef BFD64
4280 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4281 switch (flag)
4282 {
91d6fa6a
NC		 4283 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4284 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4285 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4286 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4287 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4288 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4289 default: break;
4290 }
4291#endif
cfcac11d
NC		 4292 break;
4293
caa83f8b
NC		 4294 case EM_386:
4295 case EM_486:
4296 case EM_X86_64:
7f502d6c 4297 case EM_L1OM:
cfcac11d
NC		 4298 case EM_OLD_SPARCV9:
4299 case EM_SPARC32PLUS:
4300 case EM_SPARCV9:
4301 case EM_SPARC:
18ae9cc1 4302 if (flag == SHF_ORDERED)
91d6fa6a 4303 sindex = 19;
cfcac11d
NC		 4304 break;
4305 default:
4306 break;
148b93f2 4307 }
5477e8a0
L		 4308 }
4309
91d6fa6a 4310 if (sindex != -1)
5477e8a0 4311 {
8d5ff12c
L		 4312 if (p != buff + field_size + 4)
4313 {
4314 if (size < (10 + 2))
4315 abort ();
4316 size -= 2;
4317 *p++ = ',';
4318 *p++ = ' ';
4319 }
4320
91d6fa6a
NC		 4321 size -= flags [sindex].len;
4322 p = stpcpy (p, flags [sindex].str);
5477e8a0 4323 }
3b22753a 4324 else if (flag & SHF_MASKOS)
8d5ff12c 4325 os_flags |= flag;
d1133906 4326 else if (flag & SHF_MASKPROC)
8d5ff12c 4327 proc_flags |= flag;
d1133906 4328 else
8d5ff12c 4329 unknown_flags |= flag;
5477e8a0
L		 4330 }
4331 else
4332 {
4333 switch (flag)
4334 {
4335 case SHF_WRITE: *p = 'W'; break;
4336 case SHF_ALLOC: *p = 'A'; break;
4337 case SHF_EXECINSTR: *p = 'X'; break;
4338 case SHF_MERGE: *p = 'M'; break;
4339 case SHF_STRINGS: *p = 'S'; break;
4340 case SHF_INFO_LINK: *p = 'I'; break;
4341 case SHF_LINK_ORDER: *p = 'L'; break;
4342 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4343 case SHF_GROUP: *p = 'G'; break;
4344 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4345 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4346
4347 default:
8a9036a4
L		 4348 if ((elf_header.e_machine == EM_X86_64
4349 || elf_header.e_machine == EM_L1OM)
5477e8a0
L		 4350 && flag == SHF_X86_64_LARGE)
4351 *p = 'l';
4352 else if (flag & SHF_MASKOS)
4353 {
4354 *p = 'o';
4355 sh_flags &= ~ SHF_MASKOS;
4356 }
4357 else if (flag & SHF_MASKPROC)
4358 {
4359 *p = 'p';
4360 sh_flags &= ~ SHF_MASKPROC;
4361 }
4362 else
4363 *p = 'x';
4364 break;
4365 }
4366 p++;
d1133906
NC		 4367 }
4368 }
76da6bbe 4369
8d5ff12c
L		 4370 if (do_section_details)
4371 {
4372 if (os_flags)
4373 {
4374 size -= 5 + field_size;
4375 if (p != buff + field_size + 4)
4376 {
4377 if (size < (2 + 1))
4378 abort ();
4379 size -= 2;
4380 *p++ = ',';
4381 *p++ = ' ';
4382 }
4383 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4384 (unsigned long) os_flags);
4385 p += 5 + field_size;
4386 }
4387 if (proc_flags)
4388 {
4389 size -= 7 + field_size;
4390 if (p != buff + field_size + 4)
4391 {
4392 if (size < (2 + 1))
4393 abort ();
4394 size -= 2;
4395 *p++ = ',';
4396 *p++ = ' ';
4397 }
4398 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4399 (unsigned long) proc_flags);
4400 p += 7 + field_size;
4401 }
4402 if (unknown_flags)
4403 {
4404 size -= 10 + field_size;
4405 if (p != buff + field_size + 4)
4406 {
4407 if (size < (2 + 1))
4408 abort ();
4409 size -= 2;
4410 *p++ = ',';
4411 *p++ = ' ';
4412 }
2b692964 4413 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4414 (unsigned long) unknown_flags);
4415 p += 10 + field_size;
4416 }
4417 }
4418
e9e44622 4419 *p = '\0';
d1133906
NC		 4420 return buff;
4421}
4422
252b5132 4423static int
2cf0635d 4424process_section_headers (FILE * file)
252b5132 4425{
2cf0635d 4426 Elf_Internal_Shdr * section;
b34976b6 4427 unsigned int i;
252b5132
RH		 4428
4429 section_headers = NULL;
4430
4431 if (elf_header.e_shnum == 0)
4432 {
82f2dbf7
NC		 4433 /* PR binutils/12467. */
4434 if (elf_header.e_shoff != 0)
4435 warn (_("possibly corrupt ELF file header - it has a non-zero"
4436 " section header offset, but no section headers\n"));
4437 else if (do_sections)
252b5132
RH		 4438 printf (_("\nThere are no sections in this file.\n"));
4439
4440 return 1;
4441 }
4442
4443 if (do_sections && !do_header)
9ea033b2 4444 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4445 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4446
9ea033b2
NC		 4447 if (is_32bit_elf)
4448 {
560f3c1c 4449 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4450 return 0;
4451 }
560f3c1c 4452 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4453 return 0;
4454
4455 /* Read in the string table, so that we have names to display. */
0b49d371 4456 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4457 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4458 {
4fbb74a6 4459 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4460
c256ffe7
JJ		 4461 if (section->sh_size != 0)
4462 {
3f5e193b
NC		 4463 string_table = (char *) get_data (NULL, file, section->sh_offset,
4464 1, section->sh_size,
4465 _("string table"));
0de14b54 4466
c256ffe7
JJ		 4467 string_table_length = string_table != NULL ? section->sh_size : 0;
4468 }
252b5132
RH		 4469 }
4470
4471 /* Scan the sections for the dynamic symbol table
e3c8793a 4472 and dynamic string table and debug sections. */
252b5132
RH		 4473 dynamic_symbols = NULL;
4474 dynamic_strings = NULL;
4475 dynamic_syminfo = NULL;
f1ef08cb 4476 symtab_shndx_hdr = NULL;
103f02d3 4477
89fac5e3
RS		 4478 eh_addr_size = is_32bit_elf ? 4 : 8;
4479 switch (elf_header.e_machine)
4480 {
4481 case EM_MIPS:
4482 case EM_MIPS_RS3_LE:
4483 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4484 FDE addresses. However, the ABI also has a semi-official ILP32
4485 variant for which the normal FDE address size rules apply.
4486
4487 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4488 section, where XX is the size of longs in bits. Unfortunately,
4489 earlier compilers provided no way of distinguishing ILP32 objects
4490 from LP64 objects, so if there's any doubt, we should assume that
4491 the official LP64 form is being used. */
4492 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4493 && find_section (".gcc_compiled_long32") == NULL)
4494 eh_addr_size = 8;
4495 break;
0f56a26a
DD		 4496
4497 case EM_H8_300:
4498 case EM_H8_300H:
4499 switch (elf_header.e_flags & EF_H8_MACH)
4500 {
4501 case E_H8_MACH_H8300:
4502 case E_H8_MACH_H8300HN:
4503 case E_H8_MACH_H8300SN:
4504 case E_H8_MACH_H8300SXN:
4505 eh_addr_size = 2;
4506 break;
4507 case E_H8_MACH_H8300H:
4508 case E_H8_MACH_H8300S:
4509 case E_H8_MACH_H8300SX:
4510 eh_addr_size = 4;
4511 break;
4512 }
f4236fe4
DD		 4513 break;
4514
ff7eeb89 4515 case EM_M32C_OLD:
f4236fe4
DD		 4516 case EM_M32C:
4517 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4518 {
4519 case EF_M32C_CPU_M16C:
4520 eh_addr_size = 2;
4521 break;
4522 }
4523 break;
89fac5e3
RS		 4524 }
4525
08d8fa11
JJ		 4526#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4527 do \
4528 { \
4529 size_t expected_entsize \
4530 = is_32bit_elf ? size32 : size64; \
4531 if (section->sh_entsize != expected_entsize) \
4532 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4533 i, (unsigned long int) section->sh_entsize, \
4534 (unsigned long int) expected_entsize); \
4535 section->sh_entsize = expected_entsize; \
4536 } \
4537 while (0)
4538#define CHECK_ENTSIZE(section, i, type) \
4539 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4540 sizeof (Elf64_External_##type))
4541
252b5132
RH		 4542 for (i = 0, section = section_headers;
4543 i < elf_header.e_shnum;
b34976b6 4544 i++, section++)
252b5132 4545 {
2cf0635d 4546 char * name = SECTION_NAME (section);
252b5132
RH		 4547
4548 if (section->sh_type == SHT_DYNSYM)
4549 {
4550 if (dynamic_symbols != NULL)
4551 {
4552 error (_("File contains multiple dynamic symbol tables\n"));
4553 continue;
4554 }
4555
08d8fa11 4556 CHECK_ENTSIZE (section, i, Sym);
19936277 4557 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4558 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4559 }
4560 else if (section->sh_type == SHT_STRTAB
18bd398b 4561 && streq (name, ".dynstr"))
252b5132
RH		 4562 {
4563 if (dynamic_strings != NULL)
4564 {
4565 error (_("File contains multiple dynamic string tables\n"));
4566 continue;
4567 }
4568
3f5e193b
NC		 4569 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4570 1, section->sh_size,
4571 _("dynamic strings"));
59245841 4572 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4573 }
9ad5cbcf
AM		 4574 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4575 {
4576 if (symtab_shndx_hdr != NULL)
4577 {
4578 error (_("File contains multiple symtab shndx tables\n"));
4579 continue;
4580 }
4581 symtab_shndx_hdr = section;
4582 }
08d8fa11
JJ		 4583 else if (section->sh_type == SHT_SYMTAB)
4584 CHECK_ENTSIZE (section, i, Sym);
4585 else if (section->sh_type == SHT_GROUP)
4586 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4587 else if (section->sh_type == SHT_REL)
4588 CHECK_ENTSIZE (section, i, Rel);
4589 else if (section->sh_type == SHT_RELA)
4590 CHECK_ENTSIZE (section, i, Rela);
252b5132 4591 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4592 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4593 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4594 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4595 && (const_strneq (name, ".debug_")
4596 || const_strneq (name, ".zdebug_")))
252b5132 4597 {
1b315056
CS		 4598 if (name[1] == 'z')
4599 name += sizeof (".zdebug_") - 1;
4600 else
4601 name += sizeof (".debug_") - 1;
252b5132
RH		 4602
4603 if (do_debugging
18bd398b 4604 || (do_debug_info && streq (name, "info"))
2b6f5997 4605 || (do_debug_info && streq (name, "types"))
18bd398b 4606 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4607 || (do_debug_lines && streq (name, "line"))
18bd398b 4608 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4609 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4610 || (do_debug_aranges && streq (name, "aranges"))
4611 || (do_debug_ranges && streq (name, "ranges"))
4612 || (do_debug_frames && streq (name, "frame"))
4613 || (do_debug_macinfo && streq (name, "macinfo"))
4614 || (do_debug_str && streq (name, "str"))
4615 || (do_debug_loc && streq (name, "loc"))
252b5132 4616 )
09c11c86 4617 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4618 }
a262ae96 4619 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4620 else if ((do_debugging || do_debug_info)
0112cd26 4621 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4622 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4623 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4624 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4625 else if (do_gdb_index && streq (name, ".gdb_index"))
4626 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4627 /* Trace sections for Itanium VMS. */
4628 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4629 || do_trace_aranges)
4630 && const_strneq (name, ".trace_"))
4631 {
4632 name += sizeof (".trace_") - 1;
4633
4634 if (do_debugging
4635 || (do_trace_info && streq (name, "info"))
4636 || (do_trace_abbrevs && streq (name, "abbrev"))
4637 || (do_trace_aranges && streq (name, "aranges"))
4638 )
4639 request_dump_bynumber (i, DEBUG_DUMP);
4640 }
4641
252b5132
RH		 4642 }
4643
4644 if (! do_sections)
4645 return 1;
4646
3a1a2036
NC		 4647 if (elf_header.e_shnum > 1)
4648 printf (_("\nSection Headers:\n"));
4649 else
4650 printf (_("\nSection Header:\n"));
76da6bbe 4651
f7a99963 4652 if (is_32bit_elf)
595cf52e 4653 {
5477e8a0 4654 if (do_section_details)
595cf52e
L		 4655 {
4656 printf (_(" [Nr] Name\n"));
5477e8a0 4657 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4658 }
4659 else
4660 printf
4661 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4662 }
d974e256 4663 else if (do_wide)
595cf52e 4664 {
5477e8a0 4665 if (do_section_details)
595cf52e
L		 4666 {
4667 printf (_(" [Nr] Name\n"));
5477e8a0 4668 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4669 }
4670 else
4671 printf
4672 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4673 }
f7a99963
NC		 4674 else
4675 {
5477e8a0 4676 if (do_section_details)
595cf52e
L		 4677 {
4678 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4679 printf (_(" Type Address Offset Link\n"));
4680 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4681 }
4682 else
4683 {
4684 printf (_(" [Nr] Name Type Address Offset\n"));
4685 printf (_(" Size EntSize Flags Link Info Align\n"));
4686 }
f7a99963 4687 }
252b5132 4688
5477e8a0
L		 4689 if (do_section_details)
4690 printf (_(" Flags\n"));
4691
252b5132
RH		 4692 for (i = 0, section = section_headers;
4693 i < elf_header.e_shnum;
b34976b6 4694 i++, section++)
252b5132 4695 {
5477e8a0 4696 if (do_section_details)
595cf52e
L		 4697 {
4698 printf (" [%2u] %s\n",
4fbb74a6 4699 i,
595cf52e
L		 4700 SECTION_NAME (section));
4701 if (is_32bit_elf || do_wide)
4702 printf (" %-15.15s ",
4703 get_section_type_name (section->sh_type));
4704 }
4705 else
b9eb56c1
NC		 4706 printf ((do_wide ? " [%2u] %-17s %-15s "
4707 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4708 i,
595cf52e
L		 4709 SECTION_NAME (section),
4710 get_section_type_name (section->sh_type));
252b5132 4711
f7a99963
NC		 4712 if (is_32bit_elf)
4713 {
cfcac11d
NC		 4714 const char * link_too_big = NULL;
4715
f7a99963 4716 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4717
f7a99963
NC		 4718 printf ( " %6.6lx %6.6lx %2.2lx",
4719 (unsigned long) section->sh_offset,
4720 (unsigned long) section->sh_size,
4721 (unsigned long) section->sh_entsize);
d1133906 4722
5477e8a0
L		 4723 if (do_section_details)
4724 fputs (" ", stdout);
4725 else
4726 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4727
cfcac11d
NC		 4728 if (section->sh_link >= elf_header.e_shnum)
4729 {
4730 link_too_big = "";
4731 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4732 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4733 switch (elf_header.e_machine)
4734 {
caa83f8b
NC		 4735 case EM_386:
4736 case EM_486:
4737 case EM_X86_64:
7f502d6c 4738 case EM_L1OM:
cfcac11d
NC		 4739 case EM_OLD_SPARCV9:
4740 case EM_SPARC32PLUS:
4741 case EM_SPARCV9:
4742 case EM_SPARC:
4743 if (section->sh_link == (SHN_BEFORE & 0xffff))
4744 link_too_big = "BEFORE";
4745 else if (section->sh_link == (SHN_AFTER & 0xffff))
4746 link_too_big = "AFTER";
4747 break;
4748 default:
4749 break;
4750 }
4751 }
4752
4753 if (do_section_details)
4754 {
4755 if (link_too_big != NULL && * link_too_big)
4756 printf ("<%s> ", link_too_big);
4757 else
4758 printf ("%2u ", section->sh_link);
4759 printf ("%3u %2lu\n", section->sh_info,
4760 (unsigned long) section->sh_addralign);
4761 }
4762 else
4763 printf ("%2u %3u %2lu\n",
4764 section->sh_link,
4765 section->sh_info,
4766 (unsigned long) section->sh_addralign);
4767
4768 if (link_too_big && ! * link_too_big)
4769 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4770 i, section->sh_link);
f7a99963 4771 }
d974e256
JJ		 4772 else if (do_wide)
4773 {
4774 print_vma (section->sh_addr, LONG_HEX);
4775
4776 if ((long) section->sh_offset == section->sh_offset)
4777 printf (" %6.6lx", (unsigned long) section->sh_offset);
4778 else
4779 {
4780 putchar (' ');
4781 print_vma (section->sh_offset, LONG_HEX);
4782 }
4783
4784 if ((unsigned long) section->sh_size == section->sh_size)
4785 printf (" %6.6lx", (unsigned long) section->sh_size);
4786 else
4787 {
4788 putchar (' ');
4789 print_vma (section->sh_size, LONG_HEX);
4790 }
4791
4792 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4793 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4794 else
4795 {
4796 putchar (' ');
4797 print_vma (section->sh_entsize, LONG_HEX);
4798 }
4799
5477e8a0
L		 4800 if (do_section_details)
4801 fputs (" ", stdout);
4802 else
4803 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4804
72de5009 4805 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4806
4807 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4808 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4809 else
4810 {
4811 print_vma (section->sh_addralign, DEC);
4812 putchar ('\n');
4813 }
4814 }
5477e8a0 4815 else if (do_section_details)
595cf52e 4816 {
5477e8a0 4817 printf (" %-15.15s ",
595cf52e 4818 get_section_type_name (section->sh_type));
595cf52e
L		 4819 print_vma (section->sh_addr, LONG_HEX);
4820 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4821 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4822 else
4823 {
4824 printf (" ");
4825 print_vma (section->sh_offset, LONG_HEX);
4826 }
72de5009 4827 printf (" %u\n ", section->sh_link);
595cf52e 4828 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4829 putchar (' ');
595cf52e
L		 4830 print_vma (section->sh_entsize, LONG_HEX);
4831
72de5009
AM		 4832 printf (" %-16u %lu\n",
4833 section->sh_info,
595cf52e
L		 4834 (unsigned long) section->sh_addralign);
4835 }
f7a99963
NC		 4836 else
4837 {
4838 putchar (' ');
4839 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4840 if ((long) section->sh_offset == section->sh_offset)
4841 printf (" %8.8lx", (unsigned long) section->sh_offset);
4842 else
4843 {
4844 printf (" ");
4845 print_vma (section->sh_offset, LONG_HEX);
4846 }
f7a99963
NC		 4847 printf ("\n ");
4848 print_vma (section->sh_size, LONG_HEX);
4849 printf (" ");
4850 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4851
d1133906 4852 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4853
72de5009
AM		 4854 printf (" %2u %3u %lu\n",
4855 section->sh_link,
4856 section->sh_info,
f7a99963
NC		 4857 (unsigned long) section->sh_addralign);
4858 }
5477e8a0
L		 4859
4860 if (do_section_details)
4861 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4862 }
4863
5477e8a0 4864 if (!do_section_details)
3dbcc61d
NC		 4865 {
4866 if (elf_header.e_machine == EM_X86_64
4867 || elf_header.e_machine == EM_L1OM)
4868 printf (_("Key to Flags:\n\
4869 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4870 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4871 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4872 else
4873 printf (_("Key to Flags:\n\
e3c8793a 4874 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4875 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4876 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4877 }
d1133906 4878
252b5132
RH		 4879 return 1;
4880}
4881
f5842774
L		 4882static const char *
4883get_group_flags (unsigned int flags)
4884{
4885 static char buff[32];
4886 switch (flags)
4887 {
220453ec
AM		 4888 case 0:
4889 return "";
4890
f5842774 4891 case GRP_COMDAT:
220453ec 4892 return "COMDAT ";
f5842774
L		 4893
4894 default:
220453ec 4895 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4896 break;
4897 }
4898 return buff;
4899}
4900
4901static int
2cf0635d 4902process_section_groups (FILE * file)
f5842774 4903{
2cf0635d 4904 Elf_Internal_Shdr * section;
f5842774 4905 unsigned int i;
2cf0635d
NC		 4906 struct group * group;
4907 Elf_Internal_Shdr * symtab_sec;
4908 Elf_Internal_Shdr * strtab_sec;
4909 Elf_Internal_Sym * symtab;
4910 char * strtab;
c256ffe7 4911 size_t strtab_size;
d1f5c6e3
L		 4912
4913 /* Don't process section groups unless needed. */
4914 if (!do_unwind && !do_section_groups)
4915 return 1;
f5842774
L		 4916
4917 if (elf_header.e_shnum == 0)
4918 {
4919 if (do_section_groups)
82f2dbf7 4920 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4921
4922 return 1;
4923 }
4924
4925 if (section_headers == NULL)
4926 {
4927 error (_("Section headers are not available!\n"));
4928 abort ();
4929 }
4930
3f5e193b
NC		 4931 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4932 sizeof (struct group *));
e4b17d5c
L		 4933
4934 if (section_headers_groups == NULL)
4935 {
4936 error (_("Out of memory\n"));
4937 return 0;
4938 }
4939
f5842774 4940 /* Scan the sections for the group section. */
d1f5c6e3 4941 group_count = 0;
f5842774
L		 4942 for (i = 0, section = section_headers;
4943 i < elf_header.e_shnum;
4944 i++, section++)
e4b17d5c
L		 4945 if (section->sh_type == SHT_GROUP)
4946 group_count++;
4947
d1f5c6e3
L		 4948 if (group_count == 0)
4949 {
4950 if (do_section_groups)
4951 printf (_("\nThere are no section groups in this file.\n"));
4952
4953 return 1;
4954 }
4955
3f5e193b 4956 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4957
4958 if (section_groups == NULL)
4959 {
4960 error (_("Out of memory\n"));
4961 return 0;
4962 }
4963
d1f5c6e3
L		 4964 symtab_sec = NULL;
4965 strtab_sec = NULL;
4966 symtab = NULL;
4967 strtab = NULL;
c256ffe7 4968 strtab_size = 0;
e4b17d5c
L		 4969 for (i = 0, section = section_headers, group = section_groups;
4970 i < elf_header.e_shnum;
4971 i++, section++)
f5842774
L		 4972 {
4973 if (section->sh_type == SHT_GROUP)
4974 {
2cf0635d
NC		 4975 char * name = SECTION_NAME (section);
4976 char * group_name;
4977 unsigned char * start;
4978 unsigned char * indices;
f5842774 4979 unsigned int entry, j, size;
2cf0635d
NC		 4980 Elf_Internal_Shdr * sec;
4981 Elf_Internal_Sym * sym;
f5842774
L		 4982
4983 /* Get the symbol table. */
4fbb74a6
AM		 4984 if (section->sh_link >= elf_header.e_shnum
4985 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4986 != SHT_SYMTAB))
f5842774
L		 4987 {
4988 error (_("Bad sh_link in group section `%s'\n"), name);
4989 continue;
4990 }
d1f5c6e3
L		 4991
4992 if (symtab_sec != sec)
4993 {
4994 symtab_sec = sec;
4995 if (symtab)
4996 free (symtab);
4997 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4998 }
f5842774 4999
dd24e3da
NC		 5000 if (symtab == NULL)
5001 {
5002 error (_("Corrupt header in group section `%s'\n"), name);
5003 continue;
5004 }
5005
f5842774
L		 5006 sym = symtab + section->sh_info;
5007
5008 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5009 {
4fbb74a6
AM		 5010 if (sym->st_shndx == 0
5011 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5012 {
5013 error (_("Bad sh_info in group section `%s'\n"), name);
5014 continue;
5015 }
ba2685cc 5016
4fbb74a6 5017 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5018 strtab_sec = NULL;
5019 if (strtab)
5020 free (strtab);
f5842774 5021 strtab = NULL;
c256ffe7 5022 strtab_size = 0;
f5842774
L		 5023 }
5024 else
5025 {
5026 /* Get the string table. */
4fbb74a6 5027 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5028 {
5029 strtab_sec = NULL;
5030 if (strtab)
5031 free (strtab);
5032 strtab = NULL;
5033 strtab_size = 0;
5034 }
5035 else if (strtab_sec
4fbb74a6 5036 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5037 {
5038 strtab_sec = sec;
5039 if (strtab)
5040 free (strtab);
3f5e193b
NC		 5041 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5042 1, strtab_sec->sh_size,
5043 _("string table"));
c256ffe7 5044 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5045 }
c256ffe7 5046 group_name = sym->st_name < strtab_size
2b692964 5047 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5048 }
5049
3f5e193b
NC		 5050 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5051 1, section->sh_size,
5052 _("section data"));
59245841
NC		 5053 if (start == NULL)
5054 continue;
f5842774
L		 5055
5056 indices = start;
5057 size = (section->sh_size / section->sh_entsize) - 1;
5058 entry = byte_get (indices, 4);
5059 indices += 4;
e4b17d5c
L		 5060
5061 if (do_section_groups)
5062 {
2b692964 5063 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5064 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5065
e4b17d5c
L		 5066 printf (_(" [Index] Name\n"));
5067 }
5068
5069 group->group_index = i;
5070
f5842774
L		 5071 for (j = 0; j < size; j++)
5072 {
2cf0635d 5073 struct group_list * g;
e4b17d5c 5074
f5842774
L		 5075 entry = byte_get (indices, 4);
5076 indices += 4;
5077
4fbb74a6 5078 if (entry >= elf_header.e_shnum)
391cb864
L		 5079 {
5080 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5081 entry, i, elf_header.e_shnum - 1);
5082 continue;
5083 }
391cb864 5084
4fbb74a6 5085 if (section_headers_groups [entry] != NULL)
e4b17d5c 5086 {
d1f5c6e3
L		 5087 if (entry)
5088 {
391cb864
L		 5089 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5090 entry, i,
4fbb74a6 5091 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5092 continue;
5093 }
5094 else
5095 {
5096 /* Intel C/C++ compiler may put section 0 in a
5097 section group. We just warn it the first time
5098 and ignore it afterwards. */
5099 static int warned = 0;
5100 if (!warned)
5101 {
5102 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5103 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5104 warned++;
5105 }
5106 }
e4b17d5c
L		 5107 }
5108
4fbb74a6 5109 section_headers_groups [entry] = group;
e4b17d5c
L		 5110
5111 if (do_section_groups)
5112 {
4fbb74a6 5113 sec = section_headers + entry;
c256ffe7 5114 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5115 }
5116
3f5e193b 5117 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5118 g->section_index = entry;
5119 g->next = group->root;
5120 group->root = g;
f5842774
L		 5121 }
5122
f5842774
L		 5123 if (start)
5124 free (start);
e4b17d5c
L		 5125
5126 group++;
f5842774
L		 5127 }
5128 }
5129
d1f5c6e3
L		 5130 if (symtab)
5131 free (symtab);
5132 if (strtab)
5133 free (strtab);
f5842774
L		 5134 return 1;
5135}
5136
28f997cf
TG		 5137/* Data used to display dynamic fixups. */
5138
5139struct ia64_vms_dynfixup
5140{
5141 bfd_vma needed_ident; /* Library ident number. */
5142 bfd_vma needed; /* Index in the dstrtab of the library name. */
5143 bfd_vma fixup_needed; /* Index of the library. */
5144 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5145 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5146};
5147
5148/* Data used to display dynamic relocations. */
5149
5150struct ia64_vms_dynimgrela
5151{
5152 bfd_vma img_rela_cnt; /* Number of relocations. */
5153 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5154};
5155
5156/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5157 library). */
5158
5159static void
5160dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5161 const char *strtab, unsigned int strtab_sz)
5162{
5163 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5164 long i;
5165 const char *lib_name;
5166
5167 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5168 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5169 _("dynamic section image fixups"));
5170 if (!imfs)
5171 return;
5172
5173 if (fixup->needed < strtab_sz)
5174 lib_name = strtab + fixup->needed;
5175 else
5176 {
5177 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5178 (unsigned long) fixup->needed);
28f997cf
TG		 5179 lib_name = "???";
5180 }
5181 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5182 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5183 printf
5184 (_("Seg Offset Type SymVec DataType\n"));
5185
5186 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5187 {
5188 unsigned int type;
5189 const char *rtype;
5190
5191 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5192 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5193 type = BYTE_GET (imfs [i].type);
5194 rtype = elf_ia64_reloc_type (type);
5195 if (rtype == NULL)
5196 printf (" 0x%08x ", type);
5197 else
5198 printf (" %-32s ", rtype);
5199 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5200 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5201 }
5202
5203 free (imfs);
5204}
5205
5206/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5207
5208static void
5209dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5210{
5211 Elf64_External_VMS_IMAGE_RELA *imrs;
5212 long i;
5213
5214 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5215 1, imgrela->img_rela_cnt * sizeof (*imrs),
5216 _("dynamic section image relas"));
5217 if (!imrs)
5218 return;
5219
5220 printf (_("\nImage relocs\n"));
5221 printf
5222 (_("Seg Offset Type Addend Seg Sym Off\n"));
5223
5224 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5225 {
5226 unsigned int type;
5227 const char *rtype;
5228
5229 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5230 printf ("%08" BFD_VMA_FMT "x ",
5231 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5232 type = BYTE_GET (imrs [i].type);
5233 rtype = elf_ia64_reloc_type (type);
5234 if (rtype == NULL)
5235 printf ("0x%08x ", type);
5236 else
5237 printf ("%-31s ", rtype);
5238 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5239 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5240 printf ("%08" BFD_VMA_FMT "x\n",
5241 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5242 }
5243
5244 free (imrs);
5245}
5246
5247/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5248
5249static int
5250process_ia64_vms_dynamic_relocs (FILE *file)
5251{
5252 struct ia64_vms_dynfixup fixup;
5253 struct ia64_vms_dynimgrela imgrela;
5254 Elf_Internal_Dyn *entry;
5255 int res = 0;
5256 bfd_vma strtab_off = 0;
5257 bfd_vma strtab_sz = 0;
5258 char *strtab = NULL;
5259
5260 memset (&fixup, 0, sizeof (fixup));
5261 memset (&imgrela, 0, sizeof (imgrela));
5262
5263 /* Note: the order of the entries is specified by the OpenVMS specs. */
5264 for (entry = dynamic_section;
5265 entry < dynamic_section + dynamic_nent;
5266 entry++)
5267 {
5268 switch (entry->d_tag)
5269 {
5270 case DT_IA_64_VMS_STRTAB_OFFSET:
5271 strtab_off = entry->d_un.d_val;
5272 break;
5273 case DT_STRSZ:
5274 strtab_sz = entry->d_un.d_val;
5275 if (strtab == NULL)
5276 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5277 1, strtab_sz, _("dynamic string section"));
5278 break;
5279
5280 case DT_IA_64_VMS_NEEDED_IDENT:
5281 fixup.needed_ident = entry->d_un.d_val;
5282 break;
5283 case DT_NEEDED:
5284 fixup.needed = entry->d_un.d_val;
5285 break;
5286 case DT_IA_64_VMS_FIXUP_NEEDED:
5287 fixup.fixup_needed = entry->d_un.d_val;
5288 break;
5289 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5290 fixup.fixup_rela_cnt = entry->d_un.d_val;
5291 break;
5292 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5293 fixup.fixup_rela_off = entry->d_un.d_val;
5294 res++;
5295 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5296 break;
5297
5298 case DT_IA_64_VMS_IMG_RELA_CNT:
5299 imgrela.img_rela_cnt = entry->d_un.d_val;
5300 break;
5301 case DT_IA_64_VMS_IMG_RELA_OFF:
5302 imgrela.img_rela_off = entry->d_un.d_val;
5303 res++;
5304 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5305 break;
5306
5307 default:
5308 break;
5309 }
5310 }
5311
5312 if (strtab != NULL)
5313 free (strtab);
5314
5315 return res;
5316}
5317
85b1c36d 5318static struct
566b0d53 5319{
2cf0635d 5320 const char * name;
566b0d53
L		 5321 int reloc;
5322 int size;
5323 int rela;
5324} dynamic_relocations [] =
5325{
5326 { "REL", DT_REL, DT_RELSZ, FALSE },
5327 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5328 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5329};
5330
252b5132 5331/* Process the reloc section. */
18bd398b 5332
252b5132 5333static int
2cf0635d 5334process_relocs (FILE * file)
252b5132 5335{
b34976b6
AM		 5336 unsigned long rel_size;
5337 unsigned long rel_offset;
252b5132
RH		 5338
5339
5340 if (!do_reloc)
5341 return 1;
5342
5343 if (do_using_dynamic)
5344 {
566b0d53 5345 int is_rela;
2cf0635d 5346 const char * name;
566b0d53
L		 5347 int has_dynamic_reloc;
5348 unsigned int i;
0de14b54 5349
566b0d53 5350 has_dynamic_reloc = 0;
252b5132 5351
566b0d53 5352 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5353 {
566b0d53
L		 5354 is_rela = dynamic_relocations [i].rela;
5355 name = dynamic_relocations [i].name;
5356 rel_size = dynamic_info [dynamic_relocations [i].size];
5357 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5358
566b0d53
L		 5359 has_dynamic_reloc |= rel_size;
5360
5361 if (is_rela == UNKNOWN)
aa903cfb 5362 {
566b0d53
L		 5363 if (dynamic_relocations [i].reloc == DT_JMPREL)
5364 switch (dynamic_info[DT_PLTREL])
5365 {
5366 case DT_REL:
5367 is_rela = FALSE;
5368 break;
5369 case DT_RELA:
5370 is_rela = TRUE;
5371 break;
5372 }
aa903cfb 5373 }
252b5132 5374
566b0d53
L		 5375 if (rel_size)
5376 {
5377 printf
5378 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5379 name, rel_offset, rel_size);
252b5132 5380
d93f0186
NC		 5381 dump_relocations (file,
5382 offset_from_vma (file, rel_offset, rel_size),
5383 rel_size,
566b0d53 5384 dynamic_symbols, num_dynamic_syms,
d79b3d50 5385 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5386 }
252b5132 5387 }
566b0d53 5388
28f997cf
TG		 5389 if (is_ia64_vms ())
5390 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5391
566b0d53 5392 if (! has_dynamic_reloc)
252b5132
RH		 5393 printf (_("\nThere are no dynamic relocations in this file.\n"));
5394 }
5395 else
5396 {
2cf0635d 5397 Elf_Internal_Shdr * section;
b34976b6
AM		 5398 unsigned long i;
5399 int found = 0;
252b5132
RH		 5400
5401 for (i = 0, section = section_headers;
5402 i < elf_header.e_shnum;
b34976b6 5403 i++, section++)
252b5132
RH		 5404 {
5405 if ( section->sh_type != SHT_RELA
5406 && section->sh_type != SHT_REL)
5407 continue;
5408
5409 rel_offset = section->sh_offset;
5410 rel_size = section->sh_size;
5411
5412 if (rel_size)
5413 {
2cf0635d 5414 Elf_Internal_Shdr * strsec;
b34976b6 5415 int is_rela;
103f02d3 5416
252b5132
RH		 5417 printf (_("\nRelocation section "));
5418
5419 if (string_table == NULL)
19936277 5420 printf ("%d", section->sh_name);
252b5132 5421 else
3a1a2036 5422 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5423
5424 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5425 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5426
d79b3d50
NC		 5427 is_rela = section->sh_type == SHT_RELA;
5428
4fbb74a6
AM		 5429 if (section->sh_link != 0
5430 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5431 {
2cf0635d
NC		 5432 Elf_Internal_Shdr * symsec;
5433 Elf_Internal_Sym * symtab;
d79b3d50 5434 unsigned long nsyms;
c256ffe7 5435 unsigned long strtablen = 0;
2cf0635d 5436 char * strtab = NULL;
57346661 5437
4fbb74a6 5438 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5439 if (symsec->sh_type != SHT_SYMTAB
5440 && symsec->sh_type != SHT_DYNSYM)
5441 continue;
5442
af3fc3bc 5443 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5444 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5445
af3fc3bc
AM		 5446 if (symtab == NULL)
5447 continue;
252b5132 5448
4fbb74a6
AM		 5449 if (symsec->sh_link != 0
5450 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5451 {
4fbb74a6 5452 strsec = section_headers + symsec->sh_link;
103f02d3 5453
3f5e193b
NC		 5454 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5455 1, strsec->sh_size,
5456 _("string table"));
c256ffe7
JJ		 5457 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5458 }
252b5132 5459
d79b3d50
NC		 5460 dump_relocations (file, rel_offset, rel_size,
5461 symtab, nsyms, strtab, strtablen, is_rela);
5462 if (strtab)
5463 free (strtab);
5464 free (symtab);
5465 }
5466 else
5467 dump_relocations (file, rel_offset, rel_size,
5468 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5469
5470 found = 1;
5471 }
5472 }
5473
5474 if (! found)
5475 printf (_("\nThere are no relocations in this file.\n"));
5476 }
5477
5478 return 1;
5479}
5480
57346661
AM		 5481/* Process the unwind section. */
5482
4d6ed7c8
NC		 5483#include "unwind-ia64.h"
5484
5485/* An absolute address consists of a section and an offset. If the
5486 section is NULL, the offset itself is the address, otherwise, the
5487 address equals to LOAD_ADDRESS(section) + offset. */
5488
5489struct absaddr
5490 {
5491 unsigned short section;
5492 bfd_vma offset;
5493 };
5494
1949de15
L		 5495#define ABSADDR(a) \
5496 ((a).section \
5497 ? section_headers [(a).section].sh_addr + (a).offset \
5498 : (a).offset)
5499
3f5e193b
NC		 5500struct ia64_unw_table_entry
5501 {
5502 struct absaddr start;
5503 struct absaddr end;
5504 struct absaddr info;
5505 };
5506
57346661 5507struct ia64_unw_aux_info
4d6ed7c8 5508 {
3f5e193b
NC		 5509
5510 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5511 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5512 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5513 unsigned long info_size; /* Size of unwind info. */
5514 bfd_vma info_addr; /* starting address of unwind info. */
5515 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5516 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5517 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5518 char * strtab; /* The string table. */
b34976b6 5519 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5520 };
5521
4d6ed7c8 5522static void
2cf0635d 5523find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5524 unsigned long nsyms,
2cf0635d 5525 const char * strtab,
57346661 5526 unsigned long strtab_size,
d3ba0551 5527 struct absaddr addr,
2cf0635d
NC		 5528 const char ** symname,
5529 bfd_vma * offset)
4d6ed7c8 5530{
d3ba0551 5531 bfd_vma dist = 0x100000;
2cf0635d
NC		 5532 Elf_Internal_Sym * sym;
5533 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5534 unsigned long i;
5535
0b6ae522
DJ		 5536 REMOVE_ARCH_BITS (addr.offset);
5537
57346661 5538 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5539 {
0b6ae522
DJ		 5540 bfd_vma value = sym->st_value;
5541
5542 REMOVE_ARCH_BITS (value);
5543
4d6ed7c8
NC		 5544 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5545 && sym->st_name != 0
5546 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5547 && addr.offset >= value
5548 && addr.offset - value < dist)
4d6ed7c8
NC		 5549 {
5550 best = sym;
0b6ae522 5551 dist = addr.offset - value;
4d6ed7c8
NC		 5552 if (!dist)
5553 break;
5554 }
5555 }
5556 if (best)
5557 {
57346661 5558 *symname = (best->st_name >= strtab_size
2b692964 5559 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5560 *offset = dist;
5561 return;
5562 }
5563 *symname = NULL;
5564 *offset = addr.offset;
5565}
5566
5567static void
2cf0635d 5568dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5569{
2cf0635d 5570 struct ia64_unw_table_entry * tp;
4d6ed7c8 5571 int in_body;
7036c0e1 5572
4d6ed7c8
NC		 5573 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5574 {
5575 bfd_vma stamp;
5576 bfd_vma offset;
2cf0635d
NC		 5577 const unsigned char * dp;
5578 const unsigned char * head;
5579 const char * procname;
4d6ed7c8 5580
57346661
AM		 5581 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5582 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5583
5584 fputs ("\n<", stdout);
5585
5586 if (procname)
5587 {
5588 fputs (procname, stdout);
5589
5590 if (offset)
5591 printf ("+%lx", (unsigned long) offset);
5592 }
5593
5594 fputs (">: [", stdout);
5595 print_vma (tp->start.offset, PREFIX_HEX);
5596 fputc ('-', stdout);
5597 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5598 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5599 (unsigned long) (tp->info.offset - aux->seg_base));
5600
1949de15 5601 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5602 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5603
86f55779 5604 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5605 (unsigned) UNW_VER (stamp),
5606 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5607 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5608 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5609 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5610
5611 if (UNW_VER (stamp) != 1)
5612 {
2b692964 5613 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5614 continue;
5615 }
5616
5617 in_body = 0;
89fac5e3 5618 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5619 dp = unw_decode (dp, in_body, & in_body);
5620 }
5621}
5622
5623static int
2cf0635d
NC		 5624slurp_ia64_unwind_table (FILE * file,
5625 struct ia64_unw_aux_info * aux,
5626 Elf_Internal_Shdr * sec)
4d6ed7c8 5627{
89fac5e3 5628 unsigned long size, nrelas, i;
2cf0635d
NC		 5629 Elf_Internal_Phdr * seg;
5630 struct ia64_unw_table_entry * tep;
5631 Elf_Internal_Shdr * relsec;
5632 Elf_Internal_Rela * rela;
5633 Elf_Internal_Rela * rp;
5634 unsigned char * table;
5635 unsigned char * tp;
5636 Elf_Internal_Sym * sym;
5637 const char * relname;
4d6ed7c8 5638
4d6ed7c8
NC		 5639 /* First, find the starting address of the segment that includes
5640 this section: */
5641
5642 if (elf_header.e_phnum)
5643 {
d93f0186 5644 if (! get_program_headers (file))
4d6ed7c8 5645 return 0;
4d6ed7c8 5646
d93f0186
NC		 5647 for (seg = program_headers;
5648 seg < program_headers + elf_header.e_phnum;
5649 ++seg)
4d6ed7c8
NC		 5650 {
5651 if (seg->p_type != PT_LOAD)
5652 continue;
5653
5654 if (sec->sh_addr >= seg->p_vaddr
5655 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5656 {
5657 aux->seg_base = seg->p_vaddr;
5658 break;
5659 }
5660 }
4d6ed7c8
NC		 5661 }
5662
5663 /* Second, build the unwind table from the contents of the unwind section: */
5664 size = sec->sh_size;
3f5e193b
NC		 5665 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5666 _("unwind table"));
a6e9f9df
AM		 5667 if (!table)
5668 return 0;
4d6ed7c8 5669
3f5e193b
NC		 5670 aux->table = (struct ia64_unw_table_entry *)
5671 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5672 tep = aux->table;
c6a0c689 5673 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5674 {
5675 tep->start.section = SHN_UNDEF;
5676 tep->end.section = SHN_UNDEF;
5677 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5678 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5679 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5680 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5681 tep->start.offset += aux->seg_base;
5682 tep->end.offset += aux->seg_base;
5683 tep->info.offset += aux->seg_base;
5684 }
5685 free (table);
5686
41e92641 5687 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5688 for (relsec = section_headers;
5689 relsec < section_headers + elf_header.e_shnum;
5690 ++relsec)
5691 {
5692 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5693 || relsec->sh_info >= elf_header.e_shnum
5694 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5695 continue;
5696
5697 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5698 & rela, & nrelas))
5699 return 0;
5700
5701 for (rp = rela; rp < rela + nrelas; ++rp)
5702 {
aca88567
NC		 5703 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5704 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5705
0112cd26 5706 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5707 {
e5fb9629 5708 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5709 continue;
5710 }
5711
89fac5e3 5712 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5713
89fac5e3 5714 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5715 {
5716 case 0:
5717 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5718 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5719 break;
5720 case 1:
5721 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5722 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5723 break;
5724 case 2:
5725 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5726 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5727 break;
5728 default:
5729 break;
5730 }
5731 }
5732
5733 free (rela);
5734 }
5735
89fac5e3 5736 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5737 return 1;
5738}
5739
5740static int
2cf0635d 5741ia64_process_unwind (FILE * file)
4d6ed7c8 5742{
2cf0635d
NC		 5743 Elf_Internal_Shdr * sec;
5744 Elf_Internal_Shdr * unwsec = NULL;
5745 Elf_Internal_Shdr * strsec;
89fac5e3 5746 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5747 struct ia64_unw_aux_info aux;
f1467e33 5748
4d6ed7c8
NC		 5749 memset (& aux, 0, sizeof (aux));
5750
4d6ed7c8
NC		 5751 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5752 {
c256ffe7 5753 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5754 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5755 {
5756 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5757 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5758
4fbb74a6 5759 strsec = section_headers + sec->sh_link;
59245841 5760 assert (aux.strtab == NULL);
3f5e193b
NC		 5761 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5762 1, strsec->sh_size,
5763 _("string table"));
c256ffe7 5764 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5765 }
5766 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5767 unwcount++;
5768 }
5769
5770 if (!unwcount)
5771 printf (_("\nThere are no unwind sections in this file.\n"));
5772
5773 while (unwcount-- > 0)
5774 {
2cf0635d 5775 char * suffix;
579f31ac
JJ		 5776 size_t len, len2;
5777
5778 for (i = unwstart, sec = section_headers + unwstart;
5779 i < elf_header.e_shnum; ++i, ++sec)
5780 if (sec->sh_type == SHT_IA_64_UNWIND)
5781 {
5782 unwsec = sec;
5783 break;
5784 }
5785
5786 unwstart = i + 1;
5787 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5788
e4b17d5c
L		 5789 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5790 {
5791 /* We need to find which section group it is in. */
2cf0635d 5792 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5793
5794 for (; g != NULL; g = g->next)
5795 {
4fbb74a6 5796 sec = section_headers + g->section_index;
18bd398b
NC		 5797
5798 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5799 break;
e4b17d5c
L		 5800 }
5801
5802 if (g == NULL)
5803 i = elf_header.e_shnum;
5804 }
18bd398b 5805 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5806 {
18bd398b 5807 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5808 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5809 suffix = SECTION_NAME (unwsec) + len;
5810 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5811 ++i, ++sec)
18bd398b
NC		 5812 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5813 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5814 break;
5815 }
5816 else
5817 {
5818 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5819 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5820 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5821 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5822 suffix = "";
18bd398b 5823 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5824 suffix = SECTION_NAME (unwsec) + len;
5825 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5826 ++i, ++sec)
18bd398b
NC		 5827 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5828 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5829 break;
5830 }
5831
5832 if (i == elf_header.e_shnum)
5833 {
5834 printf (_("\nCould not find unwind info section for "));
5835
5836 if (string_table == NULL)
5837 printf ("%d", unwsec->sh_name);
5838 else
3a1a2036 5839 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5840 }
5841 else
4d6ed7c8 5842 {
4d6ed7c8 5843 aux.info_addr = sec->sh_addr;
3f5e193b 5844 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5845 sec->sh_size,
3f5e193b 5846 _("unwind info"));
59245841 5847 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5848
579f31ac 5849 printf (_("\nUnwind section "));
4d6ed7c8 5850
579f31ac
JJ		 5851 if (string_table == NULL)
5852 printf ("%d", unwsec->sh_name);
5853 else
3a1a2036 5854 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5855
579f31ac 5856 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5857 (unsigned long) unwsec->sh_offset,
89fac5e3 5858 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5859
579f31ac 5860 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5861
579f31ac
JJ		 5862 if (aux.table_len > 0)
5863 dump_ia64_unwind (& aux);
5864
5865 if (aux.table)
5866 free ((char *) aux.table);
5867 if (aux.info)
5868 free ((char *) aux.info);
5869 aux.table = NULL;
5870 aux.info = NULL;
5871 }
4d6ed7c8 5872 }
4d6ed7c8 5873
4d6ed7c8
NC		 5874 if (aux.symtab)
5875 free (aux.symtab);
5876 if (aux.strtab)
5877 free ((char *) aux.strtab);
5878
5879 return 1;
5880}
5881
3f5e193b
NC		 5882struct hppa_unw_table_entry
5883 {
5884 struct absaddr start;
5885 struct absaddr end;
5886 unsigned int Cannot_unwind:1; /* 0 */
5887 unsigned int Millicode:1; /* 1 */
5888 unsigned int Millicode_save_sr0:1; /* 2 */
5889 unsigned int Region_description:2; /* 3..4 */
5890 unsigned int reserved1:1; /* 5 */
5891 unsigned int Entry_SR:1; /* 6 */
5892 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5893 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5894 unsigned int Args_stored:1; /* 16 */
5895 unsigned int Variable_Frame:1; /* 17 */
5896 unsigned int Separate_Package_Body:1; /* 18 */
5897 unsigned int Frame_Extension_Millicode:1; /* 19 */
5898 unsigned int Stack_Overflow_Check:1; /* 20 */
5899 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5900 unsigned int Ada_Region:1; /* 22 */
5901 unsigned int cxx_info:1; /* 23 */
5902 unsigned int cxx_try_catch:1; /* 24 */
5903 unsigned int sched_entry_seq:1; /* 25 */
5904 unsigned int reserved2:1; /* 26 */
5905 unsigned int Save_SP:1; /* 27 */
5906 unsigned int Save_RP:1; /* 28 */
5907 unsigned int Save_MRP_in_frame:1; /* 29 */
5908 unsigned int extn_ptr_defined:1; /* 30 */
5909 unsigned int Cleanup_defined:1; /* 31 */
5910
5911 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5912 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5913 unsigned int Large_frame:1; /* 2 */
5914 unsigned int Pseudo_SP_Set:1; /* 3 */
5915 unsigned int reserved4:1; /* 4 */
5916 unsigned int Total_frame_size:27; /* 5..31 */
5917 };
5918
57346661
AM		 5919struct hppa_unw_aux_info
5920 {
3f5e193b 5921 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5922 unsigned long table_len; /* Length of unwind table. */
5923 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5924 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5925 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5926 char * strtab; /* The string table. */
57346661
AM		 5927 unsigned long strtab_size; /* Size of string table. */
5928 };
5929
5930static void
2cf0635d 5931dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5932{
2cf0635d 5933 struct hppa_unw_table_entry * tp;
57346661 5934
57346661
AM		 5935 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5936 {
5937 bfd_vma offset;
2cf0635d 5938 const char * procname;
57346661
AM		 5939
5940 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5941 aux->strtab_size, tp->start, &procname,
5942 &offset);
5943
5944 fputs ("\n<", stdout);
5945
5946 if (procname)
5947 {
5948 fputs (procname, stdout);
5949
5950 if (offset)
5951 printf ("+%lx", (unsigned long) offset);
5952 }
5953
5954 fputs (">: [", stdout);
5955 print_vma (tp->start.offset, PREFIX_HEX);
5956 fputc ('-', stdout);
5957 print_vma (tp->end.offset, PREFIX_HEX);
5958 printf ("]\n\t");
5959
18bd398b
NC		 5960#define PF(_m) if (tp->_m) printf (#_m " ");
5961#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5962 PF(Cannot_unwind);
5963 PF(Millicode);
5964 PF(Millicode_save_sr0);
18bd398b 5965 /* PV(Region_description); */
57346661
AM		 5966 PF(Entry_SR);
5967 PV(Entry_FR);
5968 PV(Entry_GR);
5969 PF(Args_stored);
5970 PF(Variable_Frame);
5971 PF(Separate_Package_Body);
5972 PF(Frame_Extension_Millicode);
5973 PF(Stack_Overflow_Check);
5974 PF(Two_Instruction_SP_Increment);
5975 PF(Ada_Region);
5976 PF(cxx_info);
5977 PF(cxx_try_catch);
5978 PF(sched_entry_seq);
5979 PF(Save_SP);
5980 PF(Save_RP);
5981 PF(Save_MRP_in_frame);
5982 PF(extn_ptr_defined);
5983 PF(Cleanup_defined);
5984 PF(MPE_XL_interrupt_marker);
5985 PF(HP_UX_interrupt_marker);
5986 PF(Large_frame);
5987 PF(Pseudo_SP_Set);
5988 PV(Total_frame_size);
5989#undef PF
5990#undef PV
5991 }
5992
18bd398b 5993 printf ("\n");
57346661
AM		 5994}
5995
5996static int
2cf0635d
NC		 5997slurp_hppa_unwind_table (FILE * file,
5998 struct hppa_unw_aux_info * aux,
5999 Elf_Internal_Shdr * sec)
57346661 6000{
1c0751b2 6001 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6002 Elf_Internal_Phdr * seg;
6003 struct hppa_unw_table_entry * tep;
6004 Elf_Internal_Shdr * relsec;
6005 Elf_Internal_Rela * rela;
6006 Elf_Internal_Rela * rp;
6007 unsigned char * table;
6008 unsigned char * tp;
6009 Elf_Internal_Sym * sym;
6010 const char * relname;
57346661 6011
57346661
AM		 6012 /* First, find the starting address of the segment that includes
6013 this section. */
6014
6015 if (elf_header.e_phnum)
6016 {
6017 if (! get_program_headers (file))
6018 return 0;
6019
6020 for (seg = program_headers;
6021 seg < program_headers + elf_header.e_phnum;
6022 ++seg)
6023 {
6024 if (seg->p_type != PT_LOAD)
6025 continue;
6026
6027 if (sec->sh_addr >= seg->p_vaddr
6028 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6029 {
6030 aux->seg_base = seg->p_vaddr;
6031 break;
6032 }
6033 }
6034 }
6035
6036 /* Second, build the unwind table from the contents of the unwind
6037 section. */
6038 size = sec->sh_size;
3f5e193b
NC		 6039 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6040 _("unwind table"));
57346661
AM		 6041 if (!table)
6042 return 0;
6043
1c0751b2
DA		 6044 unw_ent_size = 16;
6045 nentries = size / unw_ent_size;
6046 size = unw_ent_size * nentries;
57346661 6047
3f5e193b
NC		 6048 tep = aux->table = (struct hppa_unw_table_entry *)
6049 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6050
1c0751b2 6051 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6052 {
6053 unsigned int tmp1, tmp2;
6054
6055 tep->start.section = SHN_UNDEF;
6056 tep->end.section = SHN_UNDEF;
6057
1c0751b2
DA		 6058 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6059 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6060 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6061 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6062
6063 tep->start.offset += aux->seg_base;
6064 tep->end.offset += aux->seg_base;
57346661
AM		 6065
6066 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6067 tep->Millicode = (tmp1 >> 30) & 0x1;
6068 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6069 tep->Region_description = (tmp1 >> 27) & 0x3;
6070 tep->reserved1 = (tmp1 >> 26) & 0x1;
6071 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6072 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6073 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6074 tep->Args_stored = (tmp1 >> 15) & 0x1;
6075 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6076 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6077 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6078 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6079 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6080 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6081 tep->cxx_info = (tmp1 >> 8) & 0x1;
6082 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6083 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6084 tep->reserved2 = (tmp1 >> 5) & 0x1;
6085 tep->Save_SP = (tmp1 >> 4) & 0x1;
6086 tep->Save_RP = (tmp1 >> 3) & 0x1;
6087 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6088 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6089 tep->Cleanup_defined = tmp1 & 0x1;
6090
6091 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6092 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6093 tep->Large_frame = (tmp2 >> 29) & 0x1;
6094 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6095 tep->reserved4 = (tmp2 >> 27) & 0x1;
6096 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6097 }
6098 free (table);
6099
6100 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6101 for (relsec = section_headers;
6102 relsec < section_headers + elf_header.e_shnum;
6103 ++relsec)
6104 {
6105 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6106 || relsec->sh_info >= elf_header.e_shnum
6107 || section_headers + relsec->sh_info != sec)
57346661
AM		 6108 continue;
6109
6110 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6111 & rela, & nrelas))
6112 return 0;
6113
6114 for (rp = rela; rp < rela + nrelas; ++rp)
6115 {
aca88567
NC		 6116 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6117 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6118
6119 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6120 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6121 {
6122 warn (_("Skipping unexpected relocation type %s\n"), relname);
6123 continue;
6124 }
6125
6126 i = rp->r_offset / unw_ent_size;
6127
89fac5e3 6128 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6129 {
6130 case 0:
6131 aux->table[i].start.section = sym->st_shndx;
1e456d54 6132 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6133 break;
6134 case 1:
6135 aux->table[i].end.section = sym->st_shndx;
1e456d54 6136 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6137 break;
6138 default:
6139 break;
6140 }
6141 }
6142
6143 free (rela);
6144 }
6145
1c0751b2 6146 aux->table_len = nentries;
57346661
AM		 6147
6148 return 1;
6149}
6150
6151static int
2cf0635d 6152hppa_process_unwind (FILE * file)
57346661 6153{
57346661 6154 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6155 Elf_Internal_Shdr * unwsec = NULL;
6156 Elf_Internal_Shdr * strsec;
6157 Elf_Internal_Shdr * sec;
18bd398b 6158 unsigned long i;
57346661
AM		 6159
6160 memset (& aux, 0, sizeof (aux));
6161
c256ffe7
JJ		 6162 if (string_table == NULL)
6163 return 1;
57346661
AM		 6164
6165 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6166 {
c256ffe7 6167 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6168 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6169 {
6170 aux.nsyms = sec->sh_size / sec->sh_entsize;
6171 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6172
4fbb74a6 6173 strsec = section_headers + sec->sh_link;
59245841 6174 assert (aux.strtab == NULL);
3f5e193b
NC		 6175 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6176 1, strsec->sh_size,
6177 _("string table"));
c256ffe7 6178 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6179 }
18bd398b 6180 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6181 unwsec = sec;
6182 }
6183
6184 if (!unwsec)
6185 printf (_("\nThere are no unwind sections in this file.\n"));
6186
6187 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6188 {
18bd398b 6189 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6190 {
57346661
AM		 6191 printf (_("\nUnwind section "));
6192 printf (_("'%s'"), SECTION_NAME (sec));
6193
6194 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6195 (unsigned long) sec->sh_offset,
89fac5e3 6196 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6197
6198 slurp_hppa_unwind_table (file, &aux, sec);
6199 if (aux.table_len > 0)
6200 dump_hppa_unwind (&aux);
6201
6202 if (aux.table)
6203 free ((char *) aux.table);
6204 aux.table = NULL;
6205 }
6206 }
6207
6208 if (aux.symtab)
6209 free (aux.symtab);
6210 if (aux.strtab)
6211 free ((char *) aux.strtab);
6212
6213 return 1;
6214}
6215
0b6ae522
DJ		 6216struct arm_section
6217{
6218 unsigned char *data;
6219
6220 Elf_Internal_Shdr *sec;
6221 Elf_Internal_Rela *rela;
6222 unsigned long nrelas;
6223 unsigned int rel_type;
6224
6225 Elf_Internal_Rela *next_rela;
6226};
6227
6228struct arm_unw_aux_info
6229{
6230 FILE *file;
6231
6232 Elf_Internal_Sym *symtab; /* The symbol table. */
6233 unsigned long nsyms; /* Number of symbols. */
6234 char *strtab; /* The string table. */
6235 unsigned long strtab_size; /* Size of string table. */
6236};
6237
6238static const char *
6239arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6240 bfd_vma fn, struct absaddr addr)
6241{
6242 const char *procname;
6243 bfd_vma sym_offset;
6244
6245 if (addr.section == SHN_UNDEF)
6246 addr.offset = fn;
6247
6248 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6249 aux->strtab_size, addr, &procname,
6250 &sym_offset);
6251
6252 print_vma (fn, PREFIX_HEX);
6253
6254 if (procname)
6255 {
6256 fputs (" <", stdout);
6257 fputs (procname, stdout);
6258
6259 if (sym_offset)
6260 printf ("+0x%lx", (unsigned long) sym_offset);
6261 fputc ('>', stdout);
6262 }
6263
6264 return procname;
6265}
6266
6267static void
6268arm_free_section (struct arm_section *arm_sec)
6269{
6270 if (arm_sec->data != NULL)
6271 free (arm_sec->data);
6272
6273 if (arm_sec->rela != NULL)
6274 free (arm_sec->rela);
6275}
6276
6277static int
6278arm_section_get_word (struct arm_unw_aux_info *aux,
6279 struct arm_section *arm_sec,
6280 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6281 unsigned int *wordp, struct absaddr *addr)
6282{
6283 Elf_Internal_Rela *rp;
6284 Elf_Internal_Sym *sym;
6285 const char * relname;
6286 unsigned int word;
6287 bfd_boolean wrapped;
6288
6289 addr->section = SHN_UNDEF;
6290 addr->offset = 0;
6291
6292 if (sec != arm_sec->sec)
6293 {
6294 Elf_Internal_Shdr *relsec;
6295
6296 arm_free_section (arm_sec);
6297
6298 arm_sec->sec = sec;
6299 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6300 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6301 arm_sec->rela = NULL;
6302 arm_sec->nrelas = 0;
6303
6304 for (relsec = section_headers;
6305 relsec < section_headers + elf_header.e_shnum;
6306 ++relsec)
6307 {
6308 if (relsec->sh_info >= elf_header.e_shnum
6309 || section_headers + relsec->sh_info != sec)
6310 continue;
6311
6312 if (relsec->sh_type == SHT_REL)
6313 {
6314 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6315 relsec->sh_size,
6316 & arm_sec->rela, & arm_sec->nrelas))
6317 return 0;
6318 break;
6319 }
6320 else if (relsec->sh_type == SHT_RELA)
6321 {
6322 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6323 relsec->sh_size,
6324 & arm_sec->rela, & arm_sec->nrelas))
6325 return 0;
6326 break;
6327 }
6328 }
6329
6330 arm_sec->next_rela = arm_sec->rela;
6331 }
6332
6333 if (arm_sec->data == NULL)
6334 return 0;
6335
6336 word = byte_get (arm_sec->data + word_offset, 4);
6337
6338 wrapped = FALSE;
6339 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6340 {
6341 bfd_vma prelval, offset;
6342
6343 if (rp->r_offset > word_offset && !wrapped)
6344 {
6345 rp = arm_sec->rela;
6346 wrapped = TRUE;
6347 }
6348 if (rp->r_offset > word_offset)
6349 break;
6350
6351 if (rp->r_offset & 3)
6352 {
6353 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6354 (unsigned long) rp->r_offset);
6355 continue;
6356 }
6357
6358 if (rp->r_offset < word_offset)
6359 continue;
6360
fa197c1c
PB		 6361 switch (elf_header.e_machine)
6362 {
6363 case EM_ARM:
6364 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6365 break;
6366
6367 case EM_TI_C6000:
6368 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6369 break;
6370
6371 default:
6372 abort();
6373 }
0b6ae522 6374
fa197c1c
PB		 6375 if (streq (relname, "R_ARM_NONE")
6376 || streq (relname, "R_C6000_NONE"))
0b6ae522
DJ		 6377 continue;
6378
fa197c1c
PB		 6379 if (!(streq (relname, "R_ARM_PREL31")
6380 || streq (relname, "R_C6000_PREL31")))
0b6ae522
DJ		 6381 {
6382 warn (_("Skipping unexpected relocation type %s\n"), relname);
6383 continue;
6384 }
6385
6386 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6387
6388 if (arm_sec->rel_type == SHT_REL)
6389 {
6390 offset = word & 0x7fffffff;
6391 if (offset & 0x40000000)
6392 offset |= ~ (bfd_vma) 0x7fffffff;
6393 }
6394 else
6395 offset = rp->r_addend;
6396
6397 offset += sym->st_value;
6398 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6399
fa197c1c
PB		 6400 if (streq (relname, "R_C6000_PREL31"))
6401 prelval >>= 1;
6402
0b6ae522
DJ		 6403 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6404 addr->section = sym->st_shndx;
6405 addr->offset = offset;
6406 break;
6407 }
6408
6409 *wordp = word;
6410 arm_sec->next_rela = rp;
6411
6412 return 1;
6413}
6414
fa197c1c
PB		 6415static const char *tic6x_unwind_regnames[16] = {
6416 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6417 "A14", "A13", "A12", "A11", "A10",
6418 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6419
0b6ae522 6420static void
fa197c1c 6421decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6422{
fa197c1c
PB		 6423 int i;
6424
6425 for (i = 12; mask; mask >>= 1, i--)
6426 {
6427 if (mask & 1)
6428 {
6429 fputs (tic6x_unwind_regnames[i], stdout);
6430 if (mask > 1)
6431 fputs (", ", stdout);
6432 }
6433 }
6434}
0b6ae522
DJ		 6435
6436#define ADVANCE \
6437 if (remaining == 0 && more_words) \
6438 { \
6439 data_offset += 4; \
6440 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6441 data_offset, &word, &addr)) \
6442 return; \
6443 remaining = 4; \
6444 more_words--; \
6445 } \
6446
6447#define GET_OP(OP) \
6448 ADVANCE; \
6449 if (remaining) \
6450 { \
6451 remaining--; \
6452 (OP) = word >> 24; \
6453 word <<= 8; \
6454 } \
6455 else \
6456 { \
2b692964 6457 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6458 return; \
6459 } \
cc5914eb 6460 printf ("0x%02x ", OP)
0b6ae522 6461
fa197c1c
PB		 6462static void
6463decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6464 unsigned int word, unsigned int remaining,
6465 unsigned int more_words,
6466 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6467 struct arm_section *data_arm_sec)
6468{
6469 struct absaddr addr;
0b6ae522
DJ		 6470
6471 /* Decode the unwinding instructions. */
6472 while (1)
6473 {
6474 unsigned int op, op2;
6475
6476 ADVANCE;
6477 if (remaining == 0)
6478 break;
6479 remaining--;
6480 op = word >> 24;
6481 word <<= 8;
6482
cc5914eb 6483 printf (" 0x%02x ", op);
0b6ae522
DJ		 6484
6485 if ((op & 0xc0) == 0x00)
6486 {
6487 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6488
cc5914eb 6489 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6490 }
6491 else if ((op & 0xc0) == 0x40)
6492 {
6493 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6494
cc5914eb 6495 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6496 }
6497 else if ((op & 0xf0) == 0x80)
6498 {
6499 GET_OP (op2);
6500 if (op == 0x80 && op2 == 0)
6501 printf (_("Refuse to unwind"));
6502 else
6503 {
6504 unsigned int mask = ((op & 0x0f) << 8) | op2;
6505 int first = 1;
6506 int i;
2b692964 6507
0b6ae522
DJ		 6508 printf ("pop {");
6509 for (i = 0; i < 12; i++)
6510 if (mask & (1 << i))
6511 {
6512 if (first)
6513 first = 0;
6514 else
6515 printf (", ");
6516 printf ("r%d", 4 + i);
6517 }
6518 printf ("}");
6519 }
6520 }
6521 else if ((op & 0xf0) == 0x90)
6522 {
6523 if (op == 0x9d || op == 0x9f)
6524 printf (_(" [Reserved]"));
6525 else
cc5914eb 6526 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6527 }
6528 else if ((op & 0xf0) == 0xa0)
6529 {
6530 int end = 4 + (op & 0x07);
6531 int first = 1;
6532 int i;
61865e30 6533
0b6ae522
DJ		 6534 printf (" pop {");
6535 for (i = 4; i <= end; i++)
6536 {
6537 if (first)
6538 first = 0;
6539 else
6540 printf (", ");
6541 printf ("r%d", i);
6542 }
6543 if (op & 0x08)
6544 {
6545 if (first)
6546 printf (", ");
6547 printf ("r14");
6548 }
6549 printf ("}");
6550 }
6551 else if (op == 0xb0)
6552 printf (_(" finish"));
6553 else if (op == 0xb1)
6554 {
6555 GET_OP (op2);
6556 if (op2 == 0 || (op2 & 0xf0) != 0)
6557 printf (_("[Spare]"));
6558 else
6559 {
6560 unsigned int mask = op2 & 0x0f;
6561 int first = 1;
6562 int i;
61865e30 6563
0b6ae522
DJ		 6564 printf ("pop {");
6565 for (i = 0; i < 12; i++)
6566 if (mask & (1 << i))
6567 {
6568 if (first)
6569 first = 0;
6570 else
6571 printf (", ");
6572 printf ("r%d", i);
6573 }
6574 printf ("}");
6575 }
6576 }
6577 else if (op == 0xb2)
6578 {
b115cf96 6579 unsigned char buf[9];
0b6ae522
DJ		 6580 unsigned int i, len;
6581 unsigned long offset;
61865e30 6582
b115cf96 6583 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6584 {
6585 GET_OP (buf[i]);
6586 if ((buf[i] & 0x80) == 0)
6587 break;
6588 }
6589 assert (i < sizeof (buf));
6590 offset = read_uleb128 (buf, &len);
6591 assert (len == i + 1);
6592 offset = offset * 4 + 0x204;
cc5914eb 6593 printf ("vsp = vsp + %ld", offset);
0b6ae522 6594 }
61865e30 6595 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6596 {
61865e30
NC		 6597 unsigned int first, last;
6598
6599 GET_OP (op2);
6600 first = op2 >> 4;
6601 last = op2 & 0x0f;
6602 if (op == 0xc8)
6603 first = first + 16;
6604 printf ("pop {D%d", first);
6605 if (last)
6606 printf ("-D%d", first + last);
6607 printf ("}");
6608 }
6609 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6610 {
6611 unsigned int count = op & 0x07;
6612
6613 printf ("pop {D8");
6614 if (count)
6615 printf ("-D%d", 8 + count);
6616 printf ("}");
6617 }
6618 else if (op >= 0xc0 && op <= 0xc5)
6619 {
6620 unsigned int count = op & 0x07;
6621
6622 printf (" pop {wR10");
6623 if (count)
6624 printf ("-wR%d", 10 + count);
6625 printf ("}");
6626 }
6627 else if (op == 0xc6)
6628 {
6629 unsigned int first, last;
6630
6631 GET_OP (op2);
6632 first = op2 >> 4;
6633 last = op2 & 0x0f;
6634 printf ("pop {wR%d", first);
6635 if (last)
6636 printf ("-wR%d", first + last);
6637 printf ("}");
6638 }
6639 else if (op == 0xc7)
6640 {
6641 GET_OP (op2);
6642 if (op2 == 0 || (op2 & 0xf0) != 0)
6643 printf (_("[Spare]"));
0b6ae522
DJ		 6644 else
6645 {
61865e30
NC		 6646 unsigned int mask = op2 & 0x0f;
6647 int first = 1;
6648 int i;
6649
6650 printf ("pop {");
6651 for (i = 0; i < 4; i++)
6652 if (mask & (1 << i))
6653 {
6654 if (first)
6655 first = 0;
6656 else
6657 printf (", ");
6658 printf ("wCGR%d", i);
6659 }
6660 printf ("}");
0b6ae522
DJ		 6661 }
6662 }
61865e30
NC		 6663 else
6664 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6665 printf ("\n");
6666 }
fa197c1c
PB		 6667}
6668
6669static void
6670decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6671 unsigned int word, unsigned int remaining,
6672 unsigned int more_words,
6673 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6674 struct arm_section *data_arm_sec)
6675{
6676 struct absaddr addr;
6677
6678 /* Decode the unwinding instructions. */
6679 while (1)
6680 {
6681 unsigned int op, op2;
6682
6683 ADVANCE;
6684 if (remaining == 0)
6685 break;
6686 remaining--;
6687 op = word >> 24;
6688 word <<= 8;
6689
6690 printf (_(" 0x%02x "), op);
6691
6692 if ((op & 0xc0) == 0x00)
6693 {
6694 int offset = ((op & 0x3f) << 3) + 8;
6695 printf (_(" sp = sp + %d"), offset);
6696 }
6697 else if ((op & 0xc0) == 0x80)
6698 {
6699 GET_OP (op2);
6700 if (op == 0x80 && op2 == 0)
6701 printf (_("Refuse to unwind"));
6702 else
6703 {
6704 unsigned int mask = ((op & 0x1f) << 8) | op2;
6705 if (op & 0x20)
6706 printf ("pop compact {");
6707 else
6708 printf ("pop {");
6709
6710 decode_tic6x_unwind_regmask (mask);
6711 printf("}");
6712 }
6713 }
6714 else if ((op & 0xf0) == 0xc0)
6715 {
6716 unsigned int reg;
6717 unsigned int nregs;
6718 unsigned int i;
6719 const char *name;
6720 struct {
6721 unsigned int offset;
6722 unsigned int reg;
6723 } regpos[16];
6724
6725 /* Scan entire instruction first so that GET_OP output is not
6726 interleaved with disassembly. */
6727 nregs = 0;
6728 for (i = 0; nregs < (op & 0xf); i++)
6729 {
6730 GET_OP (op2);
6731 reg = op2 >> 4;
6732 if (reg != 0xf)
6733 {
6734 regpos[nregs].offset = i * 2;
6735 regpos[nregs].reg = reg;
6736 nregs++;
6737 }
6738
6739 reg = op2 & 0xf;
6740 if (reg != 0xf)
6741 {
6742 regpos[nregs].offset = i * 2 + 1;
6743 regpos[nregs].reg = reg;
6744 nregs++;
6745 }
6746 }
6747
6748 printf (_("pop frame {"));
6749 reg = nregs - 1;
6750 for (i = i * 2; i > 0; i--)
6751 {
6752 if (regpos[reg].offset == i - 1)
6753 {
6754 name = tic6x_unwind_regnames[regpos[reg].reg];
6755 if (reg > 0)
6756 reg--;
6757 }
6758 else
6759 name = _("[pad]");
6760
6761 fputs (name, stdout);
6762 if (i > 1)
6763 printf (", ");
6764 }
6765
6766 printf ("}");
6767 }
6768 else if (op == 0xd0)
6769 printf (" MOV FP, SP");
6770 else if (op == 0xd1)
6771 printf (" __c6xabi_pop_rts");
6772 else if (op == 0xd2)
6773 {
6774 unsigned char buf[9];
6775 unsigned int i, len;
6776 unsigned long offset;
6777 for (i = 0; i < sizeof (buf); i++)
6778 {
6779 GET_OP (buf[i]);
6780 if ((buf[i] & 0x80) == 0)
6781 break;
6782 }
6783 assert (i < sizeof (buf));
6784 offset = read_uleb128 (buf, &len);
6785 assert (len == i + 1);
6786 offset = offset * 8 + 0x408;
6787 printf (_("sp = sp + %ld"), offset);
6788 }
6789 else if ((op & 0xf0) == 0xe0)
6790 {
6791 if ((op & 0x0f) == 7)
6792 printf (" RETURN");
6793 else
6794 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6795 }
6796 else
6797 {
6798 printf (_(" [unsupported opcode]"));
6799 }
6800 putchar ('\n');
6801 }
6802}
6803
6804static bfd_vma
6805expand_prel31 (bfd_vma word, bfd_vma where)
6806{
6807 bfd_vma offset;
6808
6809 offset = word & 0x7fffffff;
6810 if (offset & 0x40000000)
6811 offset |= ~ (bfd_vma) 0x7fffffff;
6812
6813 if (elf_header.e_machine == EM_TI_C6000)
6814 offset <<= 1;
6815
6816 return offset + where;
6817}
6818
6819static void
6820decode_arm_unwind (struct arm_unw_aux_info *aux,
6821 unsigned int word, unsigned int remaining,
6822 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6823 struct arm_section *data_arm_sec)
6824{
6825 int per_index;
6826 unsigned int more_words = 0;
6827 struct absaddr addr;
6828
6829 if (remaining == 0)
6830 {
6831 /* Fetch the first word. */
6832 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6833 &word, &addr))
6834 return;
6835 remaining = 4;
6836 }
6837
6838 if ((word & 0x80000000) == 0)
6839 {
6840 /* Expand prel31 for personality routine. */
6841 bfd_vma fn;
6842 const char *procname;
6843
6844 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6845 printf (_(" Personality routine: "));
6846 procname = arm_print_vma_and_name (aux, fn, addr);
6847 fputc ('\n', stdout);
6848
6849 /* The GCC personality routines use the standard compact
6850 encoding, starting with one byte giving the number of
6851 words. */
6852 if (procname != NULL
6853 && (const_strneq (procname, "__gcc_personality_v0")
6854 || const_strneq (procname, "__gxx_personality_v0")
6855 || const_strneq (procname, "__gcj_personality_v0")
6856 || const_strneq (procname, "__gnu_objc_personality_v0")))
6857 {
6858 remaining = 0;
6859 more_words = 1;
6860 ADVANCE;
6861 if (!remaining)
6862 {
6863 printf (_(" [Truncated data]\n"));
6864 return;
6865 }
6866 more_words = word >> 24;
6867 word <<= 8;
6868 remaining--;
6869 per_index = -1;
6870 }
6871 else
6872 return;
6873 }
6874 else
6875 {
6876
6877 per_index = (word >> 24) & 0x7f;
6878 printf (_(" Compact model %d\n"), per_index);
6879 if (per_index == 0)
6880 {
6881 more_words = 0;
6882 word <<= 8;
6883 remaining--;
6884 }
6885 else if (per_index < 3)
6886 {
6887 more_words = (word >> 16) & 0xff;
6888 word <<= 16;
6889 remaining -= 2;
6890 }
6891 }
6892
6893 switch (elf_header.e_machine)
6894 {
6895 case EM_ARM:
6896 if (per_index < 3)
6897 {
6898 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6899 data_offset, data_sec, data_arm_sec);
6900 }
6901 else
6902 printf (" [reserved]\n");
6903 break;
6904
6905 case EM_TI_C6000:
6906 if (per_index < 3)
6907 {
6908 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6909 data_offset, data_sec, data_arm_sec);
6910 }
6911 else if (per_index < 5)
6912 {
6913 if (((word >> 17) & 0x7f) == 0x7f)
6914 printf (_(" Restore stack from frame pointer\n"));
6915 else
6916 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6917 printf (_(" Registers restored: "));
6918 if (per_index == 4)
6919 printf (" (compact) ");
6920 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6921 putchar ('\n');
6922 printf (_(" Return register: %s\n"),
6923 tic6x_unwind_regnames[word & 0xf]);
6924 }
6925 else
6926 printf (" [reserved]\n");
6927 break;
6928
6929 default:
6930 abort ();
6931 }
0b6ae522
DJ		 6932
6933 /* Decode the descriptors. Not implemented. */
6934}
6935
6936static void
6937dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6938{
6939 struct arm_section exidx_arm_sec, extab_arm_sec;
6940 unsigned int i, exidx_len;
6941
6942 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6943 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6944 exidx_len = exidx_sec->sh_size / 8;
6945
6946 for (i = 0; i < exidx_len; i++)
6947 {
6948 unsigned int exidx_fn, exidx_entry;
6949 struct absaddr fn_addr, entry_addr;
6950 bfd_vma fn;
6951
6952 fputc ('\n', stdout);
6953
6954 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6955 8 * i, &exidx_fn, &fn_addr)
6956 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6957 8 * i + 4, &exidx_entry, &entry_addr))
6958 {
6959 arm_free_section (&exidx_arm_sec);
6960 arm_free_section (&extab_arm_sec);
6961 return;
6962 }
6963
fa197c1c 6964 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522
DJ		 6965
6966 arm_print_vma_and_name (aux, fn, entry_addr);
6967 fputs (": ", stdout);
6968
6969 if (exidx_entry == 1)
6970 {
6971 print_vma (exidx_entry, PREFIX_HEX);
6972 fputs (" [cantunwind]\n", stdout);
6973 }
6974 else if (exidx_entry & 0x80000000)
6975 {
6976 print_vma (exidx_entry, PREFIX_HEX);
6977 fputc ('\n', stdout);
6978 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6979 }
6980 else
6981 {
8f73510c 6982 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6983 Elf_Internal_Shdr *table_sec;
6984
6985 fputs ("@", stdout);
fa197c1c 6986 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 6987 print_vma (table, PREFIX_HEX);
6988 printf ("\n");
6989
6990 /* Locate the matching .ARM.extab. */
6991 if (entry_addr.section != SHN_UNDEF
6992 && entry_addr.section < elf_header.e_shnum)
6993 {
6994 table_sec = section_headers + entry_addr.section;
6995 table_offset = entry_addr.offset;
6996 }
6997 else
6998 {
6999 table_sec = find_section_by_address (table);
7000 if (table_sec != NULL)
7001 table_offset = table - table_sec->sh_addr;
7002 }
7003 if (table_sec == NULL)
7004 {
7005 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7006 (unsigned long) table);
7007 continue;
7008 }
7009 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7010 &extab_arm_sec);
7011 }
7012 }
7013
7014 printf ("\n");
7015
7016 arm_free_section (&exidx_arm_sec);
7017 arm_free_section (&extab_arm_sec);
7018}
7019
fa197c1c 7020/* Used for both ARM and C6X unwinding tables. */
0b6ae522
DJ		 7021static int
7022arm_process_unwind (FILE *file)
7023{
7024 struct arm_unw_aux_info aux;
7025 Elf_Internal_Shdr *unwsec = NULL;
7026 Elf_Internal_Shdr *strsec;
7027 Elf_Internal_Shdr *sec;
7028 unsigned long i;
fa197c1c 7029 unsigned int sec_type;
0b6ae522
DJ		 7030
7031 memset (& aux, 0, sizeof (aux));
7032 aux.file = file;
7033
fa197c1c
PB		 7034 switch (elf_header.e_machine)
7035 {
7036 case EM_ARM:
7037 sec_type = SHT_ARM_EXIDX;
7038 break;
7039
7040 case EM_TI_C6000:
7041 sec_type = SHT_C6000_UNWIND;
7042 break;
7043
7044 default:
7045 abort();
7046 }
7047
0b6ae522
DJ		 7048 if (string_table == NULL)
7049 return 1;
7050
7051 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7052 {
7053 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7054 {
7055 aux.nsyms = sec->sh_size / sec->sh_entsize;
7056 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7057
7058 strsec = section_headers + sec->sh_link;
59245841 7059 assert (aux.strtab == NULL);
0b6ae522
DJ		 7060 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7061 1, strsec->sh_size, _("string table"));
7062 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7063 }
fa197c1c 7064 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7065 unwsec = sec;
7066 }
7067
7068 if (!unwsec)
7069 printf (_("\nThere are no unwind sections in this file.\n"));
7070
7071 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7072 {
fa197c1c 7073 if (sec->sh_type == sec_type)
0b6ae522
DJ		 7074 {
7075 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7076 SECTION_NAME (sec),
7077 (unsigned long) sec->sh_offset,
7078 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7079
7080 dump_arm_unwind (&aux, sec);
7081 }
7082 }
7083
7084 if (aux.symtab)
7085 free (aux.symtab);
7086 if (aux.strtab)
7087 free ((char *) aux.strtab);
7088
7089 return 1;
7090}
7091
57346661 7092static int
2cf0635d 7093process_unwind (FILE * file)
57346661 7094{
2cf0635d
NC		 7095 struct unwind_handler
7096 {
57346661 7097 int machtype;
2cf0635d
NC		 7098 int (* handler)(FILE *);
7099 } handlers[] =
7100 {
0b6ae522 7101 { EM_ARM, arm_process_unwind },
57346661
AM		 7102 { EM_IA_64, ia64_process_unwind },
7103 { EM_PARISC, hppa_process_unwind },
fa197c1c 7104 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7105 { 0, 0 }
7106 };
7107 int i;
7108
7109 if (!do_unwind)
7110 return 1;
7111
7112 for (i = 0; handlers[i].handler != NULL; i++)
7113 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7114 return handlers[i].handler (file);
57346661
AM		 7115
7116 printf (_("\nThere are no unwind sections in this file.\n"));
7117 return 1;
7118}
7119
252b5132 7120static void
2cf0635d 7121dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7122{
7123 switch (entry->d_tag)
7124 {
7125 case DT_MIPS_FLAGS:
7126 if (entry->d_un.d_val == 0)
2b692964 7127 printf (_("NONE\n"));
252b5132
RH		 7128 else
7129 {
7130 static const char * opts[] =
7131 {
7132 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7133 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7134 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7135 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7136 "RLD_ORDER_SAFE"
7137 };
7138 unsigned int cnt;
7139 int first = 1;
2b692964 7140
60bca95a 7141 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7142 if (entry->d_un.d_val & (1 << cnt))
7143 {
7144 printf ("%s%s", first ? "" : " ", opts[cnt]);
7145 first = 0;
7146 }
7147 puts ("");
7148 }
7149 break;
103f02d3 7150
252b5132 7151 case DT_MIPS_IVERSION:
d79b3d50 7152 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 7153 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7154 else
2b692964 7155 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 7156 break;
103f02d3 7157
252b5132
RH		 7158 case DT_MIPS_TIME_STAMP:
7159 {
7160 char timebuf[20];
2cf0635d 7161 struct tm * tmp;
50da7a9c 7162
91d6fa6a
NC		 7163 time_t atime = entry->d_un.d_val;
7164 tmp = gmtime (&atime);
e9e44622
JJ		 7165 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7166 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7167 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 7168 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 7169 }
7170 break;
103f02d3 7171
252b5132
RH		 7172 case DT_MIPS_RLD_VERSION:
7173 case DT_MIPS_LOCAL_GOTNO:
7174 case DT_MIPS_CONFLICTNO:
7175 case DT_MIPS_LIBLISTNO:
7176 case DT_MIPS_SYMTABNO:
7177 case DT_MIPS_UNREFEXTNO:
7178 case DT_MIPS_HIPAGENO:
7179 case DT_MIPS_DELTA_CLASS_NO:
7180 case DT_MIPS_DELTA_INSTANCE_NO:
7181 case DT_MIPS_DELTA_RELOC_NO:
7182 case DT_MIPS_DELTA_SYM_NO:
7183 case DT_MIPS_DELTA_CLASSSYM_NO:
7184 case DT_MIPS_COMPACT_SIZE:
7185 printf ("%ld\n", (long) entry->d_un.d_ptr);
7186 break;
103f02d3
UD		 7187
7188 default:
0af1713e 7189 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 7190 }
7191}
7192
103f02d3 7193static void
2cf0635d 7194dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7195{
7196 switch (entry->d_tag)
7197 {
7198 case DT_HP_DLD_FLAGS:
7199 {
7200 static struct
7201 {
7202 long int bit;
2cf0635d 7203 const char * str;
5e220199
NC		 7204 }
7205 flags[] =
7206 {
7207 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7208 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7209 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7210 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7211 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7212 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7213 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7214 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7215 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7216 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7217 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7218 { DT_HP_GST, "HP_GST" },
7219 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7220 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7221 { DT_HP_NODELETE, "HP_NODELETE" },
7222 { DT_HP_GROUP, "HP_GROUP" },
7223 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7224 };
103f02d3 7225 int first = 1;
5e220199 7226 size_t cnt;
f7a99963 7227 bfd_vma val = entry->d_un.d_val;
103f02d3 7228
60bca95a 7229 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7230 if (val & flags[cnt].bit)
30800947
NC		 7231 {
7232 if (! first)
7233 putchar (' ');
7234 fputs (flags[cnt].str, stdout);
7235 first = 0;
7236 val ^= flags[cnt].bit;
7237 }
76da6bbe 7238
103f02d3 7239 if (val != 0 || first)
f7a99963
NC		 7240 {
7241 if (! first)
7242 putchar (' ');
7243 print_vma (val, HEX);
7244 }
103f02d3
UD		 7245 }
7246 break;
76da6bbe 7247
252b5132 7248 default:
f7a99963
NC		 7249 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7250 break;
252b5132 7251 }
35b1837e 7252 putchar ('\n');
252b5132
RH		 7253}
7254
28f997cf
TG		 7255#ifdef BFD64
7256
7257/* VMS vs Unix time offset and factor. */
7258
7259#define VMS_EPOCH_OFFSET 35067168000000000LL
7260#define VMS_GRANULARITY_FACTOR 10000000
7261
7262/* Display a VMS time in a human readable format. */
7263
7264static void
7265print_vms_time (bfd_int64_t vmstime)
7266{
7267 struct tm *tm;
7268 time_t unxtime;
7269
7270 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7271 tm = gmtime (&unxtime);
7272 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7273 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7274 tm->tm_hour, tm->tm_min, tm->tm_sec);
7275}
7276#endif /* BFD64 */
7277
ecc51f48 7278static void
2cf0635d 7279dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7280{
7281 switch (entry->d_tag)
7282 {
0de14b54 7283 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7284 /* First 3 slots reserved. */
ecc51f48
NC		 7285 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7286 printf (" -- ");
7287 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7288 break;
7289
28f997cf
TG		 7290 case DT_IA_64_VMS_LINKTIME:
7291#ifdef BFD64
7292 print_vms_time (entry->d_un.d_val);
7293#endif
7294 break;
7295
7296 case DT_IA_64_VMS_LNKFLAGS:
7297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7298 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7299 printf (" CALL_DEBUG");
7300 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7301 printf (" NOP0BUFS");
7302 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7303 printf (" P0IMAGE");
7304 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7305 printf (" MKTHREADS");
7306 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7307 printf (" UPCALLS");
7308 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7309 printf (" IMGSTA");
7310 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7311 printf (" INITIALIZE");
7312 if (entry->d_un.d_val & VMS_LF_MAIN)
7313 printf (" MAIN");
7314 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7315 printf (" EXE_INIT");
7316 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7317 printf (" TBK_IN_IMG");
7318 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7319 printf (" DBG_IN_IMG");
7320 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7321 printf (" TBK_IN_DSF");
7322 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7323 printf (" DBG_IN_DSF");
7324 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7325 printf (" SIGNATURES");
7326 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7327 printf (" REL_SEG_OFF");
7328 break;
7329
bdf4d63a
JJ		 7330 default:
7331 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7332 break;
ecc51f48 7333 }
bdf4d63a 7334 putchar ('\n');
ecc51f48
NC		 7335}
7336
252b5132 7337static int
2cf0635d 7338get_32bit_dynamic_section (FILE * file)
252b5132 7339{
2cf0635d
NC		 7340 Elf32_External_Dyn * edyn;
7341 Elf32_External_Dyn * ext;
7342 Elf_Internal_Dyn * entry;
103f02d3 7343
3f5e193b
NC		 7344 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7345 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7346 if (!edyn)
7347 return 0;
103f02d3 7348
ba2685cc
AM		 7349/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7350 might not have the luxury of section headers. Look for the DT_NULL
7351 terminator to determine the number of entries. */
7352 for (ext = edyn, dynamic_nent = 0;
7353 (char *) ext < (char *) edyn + dynamic_size;
7354 ext++)
7355 {
7356 dynamic_nent++;
7357 if (BYTE_GET (ext->d_tag) == DT_NULL)
7358 break;
7359 }
252b5132 7360
3f5e193b
NC		 7361 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7362 sizeof (* entry));
b2d38a17 7363 if (dynamic_section == NULL)
252b5132 7364 {
9ea033b2
NC		 7365 error (_("Out of memory\n"));
7366 free (edyn);
7367 return 0;
7368 }
252b5132 7369
fb514b26 7370 for (ext = edyn, entry = dynamic_section;
ba2685cc 7371 entry < dynamic_section + dynamic_nent;
fb514b26 7372 ext++, entry++)
9ea033b2 7373 {
fb514b26
AM		 7374 entry->d_tag = BYTE_GET (ext->d_tag);
7375 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7376 }
7377
9ea033b2
NC		 7378 free (edyn);
7379
7380 return 1;
7381}
7382
7383static int
2cf0635d 7384get_64bit_dynamic_section (FILE * file)
9ea033b2 7385{
2cf0635d
NC		 7386 Elf64_External_Dyn * edyn;
7387 Elf64_External_Dyn * ext;
7388 Elf_Internal_Dyn * entry;
103f02d3 7389
3f5e193b
NC		 7390 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7391 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7392 if (!edyn)
7393 return 0;
103f02d3 7394
ba2685cc
AM		 7395/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7396 might not have the luxury of section headers. Look for the DT_NULL
7397 terminator to determine the number of entries. */
7398 for (ext = edyn, dynamic_nent = 0;
7399 (char *) ext < (char *) edyn + dynamic_size;
7400 ext++)
7401 {
7402 dynamic_nent++;
66543521 7403 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7404 break;
7405 }
252b5132 7406
3f5e193b
NC		 7407 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7408 sizeof (* entry));
b2d38a17 7409 if (dynamic_section == NULL)
252b5132
RH		 7410 {
7411 error (_("Out of memory\n"));
7412 free (edyn);
7413 return 0;
7414 }
7415
fb514b26 7416 for (ext = edyn, entry = dynamic_section;
ba2685cc 7417 entry < dynamic_section + dynamic_nent;
fb514b26 7418 ext++, entry++)
252b5132 7419 {
66543521
AM		 7420 entry->d_tag = BYTE_GET (ext->d_tag);
7421 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7422 }
7423
7424 free (edyn);
7425
9ea033b2
NC		 7426 return 1;
7427}
7428
e9e44622
JJ		 7429static void
7430print_dynamic_flags (bfd_vma flags)
d1133906 7431{
e9e44622 7432 int first = 1;
13ae64f3 7433
d1133906
NC		 7434 while (flags)
7435 {
7436 bfd_vma flag;
7437
7438 flag = flags & - flags;
7439 flags &= ~ flag;
7440
e9e44622
JJ		 7441 if (first)
7442 first = 0;
7443 else
7444 putc (' ', stdout);
13ae64f3 7445
d1133906
NC		 7446 switch (flag)
7447 {
e9e44622
JJ		 7448 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7449 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7450 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7451 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7452 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7453 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7454 }
7455 }
e9e44622 7456 puts ("");
d1133906
NC		 7457}
7458
b2d38a17
NC		 7459/* Parse and display the contents of the dynamic section. */
7460
9ea033b2 7461static int
2cf0635d 7462process_dynamic_section (FILE * file)
9ea033b2 7463{
2cf0635d 7464 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7465
7466 if (dynamic_size == 0)
7467 {
7468 if (do_dynamic)
b2d38a17 7469 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7470
7471 return 1;
7472 }
7473
7474 if (is_32bit_elf)
7475 {
b2d38a17 7476 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7477 return 0;
7478 }
b2d38a17 7479 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7480 return 0;
7481
252b5132
RH		 7482 /* Find the appropriate symbol table. */
7483 if (dynamic_symbols == NULL)
7484 {
86dba8ee
AM		 7485 for (entry = dynamic_section;
7486 entry < dynamic_section + dynamic_nent;
7487 ++entry)
252b5132 7488 {
c8286bd1 7489 Elf_Internal_Shdr section;
252b5132
RH		 7490
7491 if (entry->d_tag != DT_SYMTAB)
7492 continue;
7493
7494 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7495
7496 /* Since we do not know how big the symbol table is,
7497 we default to reading in the entire file (!) and
7498 processing that. This is overkill, I know, but it
e3c8793a 7499 should work. */
d93f0186 7500 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7501
fb52b2f4
NC		 7502 if (archive_file_offset != 0)
7503 section.sh_size = archive_file_size - section.sh_offset;
7504 else
7505 {
7506 if (fseek (file, 0, SEEK_END))
591a748a 7507 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7508
7509 section.sh_size = ftell (file) - section.sh_offset;
7510 }
252b5132 7511
9ea033b2 7512 if (is_32bit_elf)
9ad5cbcf 7513 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7514 else
9ad5cbcf 7515 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7516
9ad5cbcf 7517 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7518 if (num_dynamic_syms < 1)
252b5132
RH		 7519 {
7520 error (_("Unable to determine the number of symbols to load\n"));
7521 continue;
7522 }
7523
9ad5cbcf 7524 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7525 }
7526 }
7527
7528 /* Similarly find a string table. */
7529 if (dynamic_strings == NULL)
7530 {
86dba8ee
AM		 7531 for (entry = dynamic_section;
7532 entry < dynamic_section + dynamic_nent;
7533 ++entry)
252b5132
RH		 7534 {
7535 unsigned long offset;
b34976b6 7536 long str_tab_len;
252b5132
RH		 7537
7538 if (entry->d_tag != DT_STRTAB)
7539 continue;
7540
7541 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7542
7543 /* Since we do not know how big the string table is,
7544 we default to reading in the entire file (!) and
7545 processing that. This is overkill, I know, but it
e3c8793a 7546 should work. */
252b5132 7547
d93f0186 7548 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7549
7550 if (archive_file_offset != 0)
7551 str_tab_len = archive_file_size - offset;
7552 else
7553 {
7554 if (fseek (file, 0, SEEK_END))
7555 error (_("Unable to seek to end of file\n"));
7556 str_tab_len = ftell (file) - offset;
7557 }
252b5132
RH		 7558
7559 if (str_tab_len < 1)
7560 {
7561 error
7562 (_("Unable to determine the length of the dynamic string table\n"));
7563 continue;
7564 }
7565
3f5e193b
NC		 7566 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7567 str_tab_len,
7568 _("dynamic string table"));
59245841 7569 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7570 break;
7571 }
7572 }
7573
7574 /* And find the syminfo section if available. */
7575 if (dynamic_syminfo == NULL)
7576 {
3e8bba36 7577 unsigned long syminsz = 0;
252b5132 7578
86dba8ee
AM		 7579 for (entry = dynamic_section;
7580 entry < dynamic_section + dynamic_nent;
7581 ++entry)
252b5132
RH		 7582 {
7583 if (entry->d_tag == DT_SYMINENT)
7584 {
7585 /* Note: these braces are necessary to avoid a syntax
7586 error from the SunOS4 C compiler. */
7587 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7588 }
7589 else if (entry->d_tag == DT_SYMINSZ)
7590 syminsz = entry->d_un.d_val;
7591 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7592 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7593 syminsz);
252b5132
RH		 7594 }
7595
7596 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7597 {
2cf0635d
NC		 7598 Elf_External_Syminfo * extsyminfo;
7599 Elf_External_Syminfo * extsym;
7600 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7601
7602 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7603 extsyminfo = (Elf_External_Syminfo *)
7604 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7605 _("symbol information"));
a6e9f9df
AM		 7606 if (!extsyminfo)
7607 return 0;
252b5132 7608
3f5e193b 7609 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7610 if (dynamic_syminfo == NULL)
7611 {
7612 error (_("Out of memory\n"));
7613 return 0;
7614 }
7615
7616 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7617 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7618 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7619 ++syminfo, ++extsym)
252b5132 7620 {
86dba8ee
AM		 7621 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7622 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7623 }
7624
7625 free (extsyminfo);
7626 }
7627 }
7628
7629 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7630 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7631 dynamic_addr, dynamic_nent);
252b5132
RH		 7632 if (do_dynamic)
7633 printf (_(" Tag Type Name/Value\n"));
7634
86dba8ee
AM		 7635 for (entry = dynamic_section;
7636 entry < dynamic_section + dynamic_nent;
7637 entry++)
252b5132
RH		 7638 {
7639 if (do_dynamic)
f7a99963 7640 {
2cf0635d 7641 const char * dtype;
e699b9ff 7642
f7a99963
NC		 7643 putchar (' ');
7644 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7645 dtype = get_dynamic_type (entry->d_tag);
7646 printf (" (%s)%*s", dtype,
7647 ((is_32bit_elf ? 27 : 19)
7648 - (int) strlen (dtype)),
f7a99963
NC		 7649 " ");
7650 }
252b5132
RH		 7651
7652 switch (entry->d_tag)
7653 {
d1133906
NC		 7654 case DT_FLAGS:
7655 if (do_dynamic)
e9e44622 7656 print_dynamic_flags (entry->d_un.d_val);
d1133906 7657 break;
76da6bbe 7658
252b5132
RH		 7659 case DT_AUXILIARY:
7660 case DT_FILTER:
019148e4
L		 7661 case DT_CONFIG:
7662 case DT_DEPAUDIT:
7663 case DT_AUDIT:
252b5132
RH		 7664 if (do_dynamic)
7665 {
019148e4 7666 switch (entry->d_tag)
b34976b6 7667 {
019148e4
L		 7668 case DT_AUXILIARY:
7669 printf (_("Auxiliary library"));
7670 break;
7671
7672 case DT_FILTER:
7673 printf (_("Filter library"));
7674 break;
7675
b34976b6 7676 case DT_CONFIG:
019148e4
L		 7677 printf (_("Configuration file"));
7678 break;
7679
7680 case DT_DEPAUDIT:
7681 printf (_("Dependency audit library"));
7682 break;
7683
7684 case DT_AUDIT:
7685 printf (_("Audit library"));
7686 break;
7687 }
252b5132 7688
d79b3d50
NC		 7689 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7690 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7691 else
f7a99963
NC		 7692 {
7693 printf (": ");
7694 print_vma (entry->d_un.d_val, PREFIX_HEX);
7695 putchar ('\n');
7696 }
252b5132
RH		 7697 }
7698 break;
7699
dcefbbbd 7700 case DT_FEATURE:
252b5132
RH		 7701 if (do_dynamic)
7702 {
7703 printf (_("Flags:"));
86f55779 7704
252b5132
RH		 7705 if (entry->d_un.d_val == 0)
7706 printf (_(" None\n"));
7707 else
7708 {
7709 unsigned long int val = entry->d_un.d_val;
86f55779 7710
252b5132
RH		 7711 if (val & DTF_1_PARINIT)
7712 {
7713 printf (" PARINIT");
7714 val ^= DTF_1_PARINIT;
7715 }
dcefbbbd
L		 7716 if (val & DTF_1_CONFEXP)
7717 {
7718 printf (" CONFEXP");
7719 val ^= DTF_1_CONFEXP;
7720 }
252b5132
RH		 7721 if (val != 0)
7722 printf (" %lx", val);
7723 puts ("");
7724 }
7725 }
7726 break;
7727
7728 case DT_POSFLAG_1:
7729 if (do_dynamic)
7730 {
7731 printf (_("Flags:"));
86f55779 7732
252b5132
RH		 7733 if (entry->d_un.d_val == 0)
7734 printf (_(" None\n"));
7735 else
7736 {
7737 unsigned long int val = entry->d_un.d_val;
86f55779 7738
252b5132
RH		 7739 if (val & DF_P1_LAZYLOAD)
7740 {
7741 printf (" LAZYLOAD");
7742 val ^= DF_P1_LAZYLOAD;
7743 }
7744 if (val & DF_P1_GROUPPERM)
7745 {
7746 printf (" GROUPPERM");
7747 val ^= DF_P1_GROUPPERM;
7748 }
7749 if (val != 0)
7750 printf (" %lx", val);
7751 puts ("");
7752 }
7753 }
7754 break;
7755
7756 case DT_FLAGS_1:
7757 if (do_dynamic)
7758 {
7759 printf (_("Flags:"));
7760 if (entry->d_un.d_val == 0)
7761 printf (_(" None\n"));
7762 else
7763 {
7764 unsigned long int val = entry->d_un.d_val;
86f55779 7765
252b5132
RH		 7766 if (val & DF_1_NOW)
7767 {
7768 printf (" NOW");
7769 val ^= DF_1_NOW;
7770 }
7771 if (val & DF_1_GLOBAL)
7772 {
7773 printf (" GLOBAL");
7774 val ^= DF_1_GLOBAL;
7775 }
7776 if (val & DF_1_GROUP)
7777 {
7778 printf (" GROUP");
7779 val ^= DF_1_GROUP;
7780 }
7781 if (val & DF_1_NODELETE)
7782 {
7783 printf (" NODELETE");
7784 val ^= DF_1_NODELETE;
7785 }
7786 if (val & DF_1_LOADFLTR)
7787 {
7788 printf (" LOADFLTR");
7789 val ^= DF_1_LOADFLTR;
7790 }
7791 if (val & DF_1_INITFIRST)
7792 {
7793 printf (" INITFIRST");
7794 val ^= DF_1_INITFIRST;
7795 }
7796 if (val & DF_1_NOOPEN)
7797 {
7798 printf (" NOOPEN");
7799 val ^= DF_1_NOOPEN;
7800 }
7801 if (val & DF_1_ORIGIN)
7802 {
7803 printf (" ORIGIN");
7804 val ^= DF_1_ORIGIN;
7805 }
7806 if (val & DF_1_DIRECT)
7807 {
7808 printf (" DIRECT");
7809 val ^= DF_1_DIRECT;
7810 }
7811 if (val & DF_1_TRANS)
7812 {
7813 printf (" TRANS");
7814 val ^= DF_1_TRANS;
7815 }
7816 if (val & DF_1_INTERPOSE)
7817 {
7818 printf (" INTERPOSE");
7819 val ^= DF_1_INTERPOSE;
7820 }
f7db6139 7821 if (val & DF_1_NODEFLIB)
dcefbbbd 7822 {
f7db6139
L		 7823 printf (" NODEFLIB");
7824 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7825 }
7826 if (val & DF_1_NODUMP)
7827 {
7828 printf (" NODUMP");
7829 val ^= DF_1_NODUMP;
7830 }
7831 if (val & DF_1_CONLFAT)
7832 {
7833 printf (" CONLFAT");
7834 val ^= DF_1_CONLFAT;
7835 }
252b5132
RH		 7836 if (val != 0)
7837 printf (" %lx", val);
7838 puts ("");
7839 }
7840 }
7841 break;
7842
7843 case DT_PLTREL:
566b0d53 7844 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7845 if (do_dynamic)
7846 puts (get_dynamic_type (entry->d_un.d_val));
7847 break;
7848
7849 case DT_NULL :
7850 case DT_NEEDED :
7851 case DT_PLTGOT :
7852 case DT_HASH :
7853 case DT_STRTAB :
7854 case DT_SYMTAB :
7855 case DT_RELA :
7856 case DT_INIT :
7857 case DT_FINI :
7858 case DT_SONAME :
7859 case DT_RPATH :
7860 case DT_SYMBOLIC:
7861 case DT_REL :
7862 case DT_DEBUG :
7863 case DT_TEXTREL :
7864 case DT_JMPREL :
019148e4 7865 case DT_RUNPATH :
252b5132
RH		 7866 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7867
7868 if (do_dynamic)
7869 {
2cf0635d 7870 char * name;
252b5132 7871
d79b3d50
NC		 7872 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7873 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7874 else
d79b3d50 7875 name = NULL;
252b5132
RH		 7876
7877 if (name)
7878 {
7879 switch (entry->d_tag)
7880 {
7881 case DT_NEEDED:
7882 printf (_("Shared library: [%s]"), name);
7883
18bd398b 7884 if (streq (name, program_interpreter))
f7a99963 7885 printf (_(" program interpreter"));
252b5132
RH		 7886 break;
7887
7888 case DT_SONAME:
f7a99963 7889 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7890 break;
7891
7892 case DT_RPATH:
f7a99963 7893 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7894 break;
7895
019148e4
L		 7896 case DT_RUNPATH:
7897 printf (_("Library runpath: [%s]"), name);
7898 break;
7899
252b5132 7900 default:
f7a99963
NC		 7901 print_vma (entry->d_un.d_val, PREFIX_HEX);
7902 break;
252b5132
RH		 7903 }
7904 }
7905 else
f7a99963
NC		 7906 print_vma (entry->d_un.d_val, PREFIX_HEX);
7907
7908 putchar ('\n');
252b5132
RH		 7909 }
7910 break;
7911
7912 case DT_PLTRELSZ:
7913 case DT_RELASZ :
7914 case DT_STRSZ :
7915 case DT_RELSZ :
7916 case DT_RELAENT :
7917 case DT_SYMENT :
7918 case DT_RELENT :
566b0d53 7919 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7920 case DT_PLTPADSZ:
7921 case DT_MOVEENT :
7922 case DT_MOVESZ :
7923 case DT_INIT_ARRAYSZ:
7924 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7925 case DT_GNU_CONFLICTSZ:
7926 case DT_GNU_LIBLISTSZ:
252b5132 7927 if (do_dynamic)
f7a99963
NC		 7928 {
7929 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7930 printf (_(" (bytes)\n"));
f7a99963 7931 }
252b5132
RH		 7932 break;
7933
7934 case DT_VERDEFNUM:
7935 case DT_VERNEEDNUM:
7936 case DT_RELACOUNT:
7937 case DT_RELCOUNT:
7938 if (do_dynamic)
f7a99963
NC		 7939 {
7940 print_vma (entry->d_un.d_val, UNSIGNED);
7941 putchar ('\n');
7942 }
252b5132
RH		 7943 break;
7944
7945 case DT_SYMINSZ:
7946 case DT_SYMINENT:
7947 case DT_SYMINFO:
7948 case DT_USED:
7949 case DT_INIT_ARRAY:
7950 case DT_FINI_ARRAY:
7951 if (do_dynamic)
7952 {
d79b3d50
NC		 7953 if (entry->d_tag == DT_USED
7954 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7955 {
2cf0635d 7956 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7957
b34976b6 7958 if (*name)
252b5132
RH		 7959 {
7960 printf (_("Not needed object: [%s]\n"), name);
7961 break;
7962 }
7963 }
103f02d3 7964
f7a99963
NC		 7965 print_vma (entry->d_un.d_val, PREFIX_HEX);
7966 putchar ('\n');
252b5132
RH		 7967 }
7968 break;
7969
7970 case DT_BIND_NOW:
7971 /* The value of this entry is ignored. */
35b1837e
AM		 7972 if (do_dynamic)
7973 putchar ('\n');
252b5132 7974 break;
103f02d3 7975
047b2264
JJ		 7976 case DT_GNU_PRELINKED:
7977 if (do_dynamic)
7978 {
2cf0635d 7979 struct tm * tmp;
91d6fa6a 7980 time_t atime = entry->d_un.d_val;
047b2264 7981
91d6fa6a 7982 tmp = gmtime (&atime);
047b2264
JJ		 7983 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7984 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7985 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7986
7987 }
7988 break;
7989
fdc90cb4
JJ		 7990 case DT_GNU_HASH:
7991 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7992 if (do_dynamic)
7993 {
7994 print_vma (entry->d_un.d_val, PREFIX_HEX);
7995 putchar ('\n');
7996 }
7997 break;
7998
252b5132
RH		 7999 default:
8000 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8001 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8002 entry->d_un.d_val;
8003
8004 if (do_dynamic)
8005 {
8006 switch (elf_header.e_machine)
8007 {
8008 case EM_MIPS:
4fe85591 8009 case EM_MIPS_RS3_LE:
b2d38a17 8010 dynamic_section_mips_val (entry);
252b5132 8011 break;
103f02d3 8012 case EM_PARISC:
b2d38a17 8013 dynamic_section_parisc_val (entry);
103f02d3 8014 break;
ecc51f48 8015 case EM_IA_64:
b2d38a17 8016 dynamic_section_ia64_val (entry);
ecc51f48 8017 break;
252b5132 8018 default:
f7a99963
NC		 8019 print_vma (entry->d_un.d_val, PREFIX_HEX);
8020 putchar ('\n');
252b5132
RH		 8021 }
8022 }
8023 break;
8024 }
8025 }
8026
8027 return 1;
8028}
8029
8030static char *
d3ba0551 8031get_ver_flags (unsigned int flags)
252b5132 8032{
b34976b6 8033 static char buff[32];
252b5132
RH		 8034
8035 buff[0] = 0;
8036
8037 if (flags == 0)
8038 return _("none");
8039
8040 if (flags & VER_FLG_BASE)
8041 strcat (buff, "BASE ");
8042
8043 if (flags & VER_FLG_WEAK)
8044 {
8045 if (flags & VER_FLG_BASE)
8046 strcat (buff, "| ");
8047
8048 strcat (buff, "WEAK ");
8049 }
8050
44ec90b9
RO		 8051 if (flags & VER_FLG_INFO)
8052 {
8053 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8054 strcat (buff, "| ");
8055
8056 strcat (buff, "INFO ");
8057 }
8058
8059 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8060 strcat (buff, _("| <unknown>"));
252b5132
RH		 8061
8062 return buff;
8063}
8064
8065/* Display the contents of the version sections. */
98fb390a 8066
252b5132 8067static int
2cf0635d 8068process_version_sections (FILE * file)
252b5132 8069{
2cf0635d 8070 Elf_Internal_Shdr * section;
b34976b6
AM		 8071 unsigned i;
8072 int found = 0;
252b5132
RH		 8073
8074 if (! do_version)
8075 return 1;
8076
8077 for (i = 0, section = section_headers;
8078 i < elf_header.e_shnum;
b34976b6 8079 i++, section++)
252b5132
RH		 8080 {
8081 switch (section->sh_type)
8082 {
8083 case SHT_GNU_verdef:
8084 {
2cf0635d 8085 Elf_External_Verdef * edefs;
b34976b6
AM		 8086 unsigned int idx;
8087 unsigned int cnt;
2cf0635d 8088 char * endbuf;
252b5132
RH		 8089
8090 found = 1;
8091
8092 printf
72de5009 8093 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8094 SECTION_NAME (section), section->sh_info);
8095
8096 printf (_(" Addr: 0x"));
8097 printf_vma (section->sh_addr);
72de5009 8098 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8099 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8100 section->sh_link < elf_header.e_shnum
8101 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8102 : _("<corrupt>"));
252b5132 8103
3f5e193b
NC		 8104 edefs = (Elf_External_Verdef *)
8105 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8106 _("version definition section"));
a6e9f9df
AM		 8107 if (!edefs)
8108 break;
59245841 8109 endbuf = (char *) edefs + section->sh_size;
252b5132 8110
b34976b6 8111 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8112 {
2cf0635d
NC		 8113 char * vstart;
8114 Elf_External_Verdef * edef;
b34976b6 8115 Elf_Internal_Verdef ent;
2cf0635d 8116 Elf_External_Verdaux * eaux;
b34976b6
AM		 8117 Elf_Internal_Verdaux aux;
8118 int j;
8119 int isum;
103f02d3 8120
dd24e3da
NC		 8121 /* Check for negative or very large indicies. */
8122 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8123 break;
8124
252b5132 8125 vstart = ((char *) edefs) + idx;
54806181
AM		 8126 if (vstart + sizeof (*edef) > endbuf)
8127 break;
252b5132
RH		 8128
8129 edef = (Elf_External_Verdef *) vstart;
8130
8131 ent.vd_version = BYTE_GET (edef->vd_version);
8132 ent.vd_flags = BYTE_GET (edef->vd_flags);
8133 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8134 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8135 ent.vd_hash = BYTE_GET (edef->vd_hash);
8136 ent.vd_aux = BYTE_GET (edef->vd_aux);
8137 ent.vd_next = BYTE_GET (edef->vd_next);
8138
8139 printf (_(" %#06x: Rev: %d Flags: %s"),
8140 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8141
8142 printf (_(" Index: %d Cnt: %d "),
8143 ent.vd_ndx, ent.vd_cnt);
8144
dd24e3da
NC		 8145 /* Check for overflow. */
8146 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8147 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8148 break;
8149
252b5132
RH		 8150 vstart += ent.vd_aux;
8151
8152 eaux = (Elf_External_Verdaux *) vstart;
8153
8154 aux.vda_name = BYTE_GET (eaux->vda_name);
8155 aux.vda_next = BYTE_GET (eaux->vda_next);
8156
d79b3d50
NC		 8157 if (VALID_DYNAMIC_NAME (aux.vda_name))
8158 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8159 else
8160 printf (_("Name index: %ld\n"), aux.vda_name);
8161
8162 isum = idx + ent.vd_aux;
8163
b34976b6 8164 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8165 {
dd24e3da
NC		 8166 /* Check for overflow. */
8167 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8168 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8169 break;
8170
252b5132
RH		 8171 isum += aux.vda_next;
8172 vstart += aux.vda_next;
8173
8174 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8175 if (vstart + sizeof (*eaux) > endbuf)
8176 break;
252b5132
RH		 8177
8178 aux.vda_name = BYTE_GET (eaux->vda_name);
8179 aux.vda_next = BYTE_GET (eaux->vda_next);
8180
d79b3d50 8181 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8182 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8183 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8184 else
8185 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8186 isum, j, aux.vda_name);
8187 }
dd24e3da 8188
54806181
AM		 8189 if (j < ent.vd_cnt)
8190 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8191
8192 idx += ent.vd_next;
8193 }
dd24e3da 8194
54806181
AM		 8195 if (cnt < section->sh_info)
8196 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8197
8198 free (edefs);
8199 }
8200 break;
103f02d3 8201
252b5132
RH		 8202 case SHT_GNU_verneed:
8203 {
2cf0635d 8204 Elf_External_Verneed * eneed;
b34976b6
AM		 8205 unsigned int idx;
8206 unsigned int cnt;
2cf0635d 8207 char * endbuf;
252b5132
RH		 8208
8209 found = 1;
8210
72de5009 8211 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8212 SECTION_NAME (section), section->sh_info);
8213
8214 printf (_(" Addr: 0x"));
8215 printf_vma (section->sh_addr);
72de5009 8216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8217 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8218 section->sh_link < elf_header.e_shnum
8219 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8220 : _("<corrupt>"));
252b5132 8221
3f5e193b
NC		 8222 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8223 section->sh_offset, 1,
8224 section->sh_size,
8225 _("version need section"));
a6e9f9df
AM		 8226 if (!eneed)
8227 break;
59245841 8228 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8229
8230 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8231 {
2cf0635d 8232 Elf_External_Verneed * entry;
b34976b6
AM		 8233 Elf_Internal_Verneed ent;
8234 int j;
8235 int isum;
2cf0635d 8236 char * vstart;
252b5132 8237
dd24e3da
NC		 8238 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8239 break;
8240
252b5132 8241 vstart = ((char *) eneed) + idx;
54806181
AM		 8242 if (vstart + sizeof (*entry) > endbuf)
8243 break;
252b5132
RH		 8244
8245 entry = (Elf_External_Verneed *) vstart;
8246
8247 ent.vn_version = BYTE_GET (entry->vn_version);
8248 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8249 ent.vn_file = BYTE_GET (entry->vn_file);
8250 ent.vn_aux = BYTE_GET (entry->vn_aux);
8251 ent.vn_next = BYTE_GET (entry->vn_next);
8252
8253 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8254
d79b3d50
NC		 8255 if (VALID_DYNAMIC_NAME (ent.vn_file))
8256 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8257 else
8258 printf (_(" File: %lx"), ent.vn_file);
8259
8260 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8261
dd24e3da
NC		 8262 /* Check for overflow. */
8263 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8264 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8265 break;
8266
252b5132
RH		 8267 vstart += ent.vn_aux;
8268
8269 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8270 {
2cf0635d 8271 Elf_External_Vernaux * eaux;
b34976b6 8272 Elf_Internal_Vernaux aux;
252b5132 8273
54806181
AM		 8274 if (vstart + sizeof (*eaux) > endbuf)
8275 break;
252b5132
RH		 8276 eaux = (Elf_External_Vernaux *) vstart;
8277
8278 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8279 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8280 aux.vna_other = BYTE_GET (eaux->vna_other);
8281 aux.vna_name = BYTE_GET (eaux->vna_name);
8282 aux.vna_next = BYTE_GET (eaux->vna_next);
8283
d79b3d50 8284 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8285 printf (_(" %#06x: Name: %s"),
d79b3d50 8286 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8287 else
ecc2063b 8288 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8289 isum, aux.vna_name);
8290
8291 printf (_(" Flags: %s Version: %d\n"),
8292 get_ver_flags (aux.vna_flags), aux.vna_other);
8293
dd24e3da
NC		 8294 /* Check for overflow. */
8295 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8296 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8297 break;
8298
252b5132
RH		 8299 isum += aux.vna_next;
8300 vstart += aux.vna_next;
8301 }
54806181
AM		 8302 if (j < ent.vn_cnt)
8303 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 8304
8305 idx += ent.vn_next;
8306 }
54806181
AM		 8307 if (cnt < section->sh_info)
8308 printf (_(" Version need past end of section\n"));
103f02d3 8309
252b5132
RH		 8310 free (eneed);
8311 }
8312 break;
8313
8314 case SHT_GNU_versym:
8315 {
2cf0635d 8316 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8317 int total;
8318 int cnt;
2cf0635d
NC		 8319 unsigned char * edata;
8320 unsigned short * data;
8321 char * strtab;
8322 Elf_Internal_Sym * symbols;
8323 Elf_Internal_Shdr * string_sec;
d3ba0551 8324 long off;
252b5132 8325
4fbb74a6 8326 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8327 break;
8328
4fbb74a6 8329 link_section = section_headers + section->sh_link;
08d8fa11 8330 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8331
4fbb74a6 8332 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8333 break;
8334
252b5132
RH		 8335 found = 1;
8336
9ad5cbcf 8337 symbols = GET_ELF_SYMBOLS (file, link_section);
dd24e3da
NC		 8338 if (symbols == NULL)
8339 break;
252b5132 8340
4fbb74a6 8341 string_sec = section_headers + link_section->sh_link;
252b5132 8342
3f5e193b
NC		 8343 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8344 string_sec->sh_size,
8345 _("version string table"));
a6e9f9df 8346 if (!strtab)
0429c154
MS		 8347 {
8348 free (symbols);
8349 break;
8350 }
252b5132
RH		 8351
8352 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8353 SECTION_NAME (section), total);
8354
8355 printf (_(" Addr: "));
8356 printf_vma (section->sh_addr);
72de5009 8357 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8358 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8359 SECTION_NAME (link_section));
8360
d3ba0551
AM		 8361 off = offset_from_vma (file,
8362 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8363 total * sizeof (short));
3f5e193b
NC		 8364 edata = (unsigned char *) get_data (NULL, file, off, total,
8365 sizeof (short),
8366 _("version symbol data"));
a6e9f9df
AM		 8367 if (!edata)
8368 {
8369 free (strtab);
0429c154 8370 free (symbols);
a6e9f9df
AM		 8371 break;
8372 }
252b5132 8373
3f5e193b 8374 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8375
8376 for (cnt = total; cnt --;)
b34976b6
AM		 8377 data[cnt] = byte_get (edata + cnt * sizeof (short),
8378 sizeof (short));
252b5132
RH		 8379
8380 free (edata);
8381
8382 for (cnt = 0; cnt < total; cnt += 4)
8383 {
8384 int j, nn;
00d93f34 8385 int check_def, check_need;
2cf0635d 8386 char * name;
252b5132
RH		 8387
8388 printf (" %03x:", cnt);
8389
8390 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8391 switch (data[cnt + j])
252b5132
RH		 8392 {
8393 case 0:
8394 fputs (_(" 0 (*local*) "), stdout);
8395 break;
8396
8397 case 1:
8398 fputs (_(" 1 (*global*) "), stdout);
8399 break;
8400
8401 default:
c244d050
NC		 8402 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8403 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8404
dd24e3da
NC		 8405 /* If this index value is greater than the size of the symbols
8406 array, break to avoid an out-of-bounds read, */
8407 if ((unsigned long)(cnt + j) >=
8408 ((unsigned long)link_section->sh_size /
8409 (unsigned long)link_section->sh_entsize))
8410 {
8411 warn (_("invalid index into symbol array\n"));
8412 break;
8413 }
8414
00d93f34
JJ		 8415 check_def = 1;
8416 check_need = 1;
4fbb74a6
AM		 8417 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8418 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8419 != SHT_NOBITS)
252b5132 8420 {
b34976b6 8421 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8422 check_def = 0;
8423 else
8424 check_need = 0;
252b5132 8425 }
00d93f34
JJ		 8426
8427 if (check_need
b34976b6 8428 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8429 {
b34976b6
AM		 8430 Elf_Internal_Verneed ivn;
8431 unsigned long offset;
252b5132 8432
d93f0186
NC		 8433 offset = offset_from_vma
8434 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8435 sizeof (Elf_External_Verneed));
252b5132 8436
b34976b6 8437 do
252b5132 8438 {
b34976b6
AM		 8439 Elf_Internal_Vernaux ivna;
8440 Elf_External_Verneed evn;
8441 Elf_External_Vernaux evna;
8442 unsigned long a_off;
252b5132 8443
59245841
NC		 8444 if (get_data (&evn, file, offset, sizeof (evn), 1,
8445 _("version need")) == NULL)
8446 break;
8447
252b5132
RH		 8448 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8449 ivn.vn_next = BYTE_GET (evn.vn_next);
8450
8451 a_off = offset + ivn.vn_aux;
8452
8453 do
8454 {
59245841
NC		 8455 if (get_data (&evna, file, a_off, sizeof (evna),
8456 1, _("version need aux (2)")) == NULL)
8457 {
8458 ivna.vna_next = 0;
8459 ivna.vna_other = 0;
8460 }
8461 else
8462 {
8463 ivna.vna_next = BYTE_GET (evna.vna_next);
8464 ivna.vna_other = BYTE_GET (evna.vna_other);
8465 }
252b5132
RH		 8466
8467 a_off += ivna.vna_next;
8468 }
b34976b6 8469 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8470 && ivna.vna_next != 0);
8471
b34976b6 8472 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8473 {
8474 ivna.vna_name = BYTE_GET (evna.vna_name);
8475
54806181
AM		 8476 if (ivna.vna_name >= string_sec->sh_size)
8477 name = _("*invalid*");
8478 else
8479 name = strtab + ivna.vna_name;
252b5132 8480 nn += printf ("(%s%-*s",
16062207
ILT		 8481 name,
8482 12 - (int) strlen (name),
252b5132 8483 ")");
00d93f34 8484 check_def = 0;
252b5132
RH		 8485 break;
8486 }
8487
8488 offset += ivn.vn_next;
8489 }
8490 while (ivn.vn_next);
8491 }
00d93f34 8492
b34976b6
AM		 8493 if (check_def && data[cnt + j] != 0x8001
8494 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8495 {
b34976b6
AM		 8496 Elf_Internal_Verdef ivd;
8497 Elf_External_Verdef evd;
8498 unsigned long offset;
252b5132 8499
d93f0186
NC		 8500 offset = offset_from_vma
8501 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8502 sizeof evd);
252b5132
RH		 8503
8504 do
8505 {
59245841
NC		 8506 if (get_data (&evd, file, offset, sizeof (evd), 1,
8507 _("version def")) == NULL)
8508 {
8509 ivd.vd_next = 0;
8510 ivd.vd_ndx = 0;
8511 }
8512 else
8513 {
8514 ivd.vd_next = BYTE_GET (evd.vd_next);
8515 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8516 }
252b5132
RH		 8517
8518 offset += ivd.vd_next;
8519 }
c244d050 8520 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8521 && ivd.vd_next != 0);
8522
c244d050 8523 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8524 {
b34976b6
AM		 8525 Elf_External_Verdaux evda;
8526 Elf_Internal_Verdaux ivda;
252b5132
RH		 8527
8528 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8529
59245841
NC		 8530 if (get_data (&evda, file,
8531 offset - ivd.vd_next + ivd.vd_aux,
8532 sizeof (evda), 1,
8533 _("version def aux")) == NULL)
8534 break;
252b5132
RH		 8535
8536 ivda.vda_name = BYTE_GET (evda.vda_name);
8537
54806181
AM		 8538 if (ivda.vda_name >= string_sec->sh_size)
8539 name = _("*invalid*");
8540 else
8541 name = strtab + ivda.vda_name;
252b5132 8542 nn += printf ("(%s%-*s",
16062207
ILT		 8543 name,
8544 12 - (int) strlen (name),
252b5132
RH		 8545 ")");
8546 }
8547 }
8548
8549 if (nn < 18)
8550 printf ("%*c", 18 - nn, ' ');
8551 }
8552
8553 putchar ('\n');
8554 }
8555
8556 free (data);
8557 free (strtab);
8558 free (symbols);
8559 }
8560 break;
103f02d3 8561
252b5132
RH		 8562 default:
8563 break;
8564 }
8565 }
8566
8567 if (! found)
8568 printf (_("\nNo version information found in this file.\n"));
8569
8570 return 1;
8571}
8572
d1133906 8573static const char *
d3ba0551 8574get_symbol_binding (unsigned int binding)
252b5132 8575{
b34976b6 8576 static char buff[32];
252b5132
RH		 8577
8578 switch (binding)
8579 {
b34976b6
AM		 8580 case STB_LOCAL: return "LOCAL";
8581 case STB_GLOBAL: return "GLOBAL";
8582 case STB_WEAK: return "WEAK";
252b5132
RH		 8583 default:
8584 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8585 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8586 binding);
252b5132 8587 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8588 {
8589 if (binding == STB_GNU_UNIQUE
8590 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8591 /* GNU/Linux is still using the default value 0. */
8592 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8593 return "UNIQUE";
8594 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8595 }
252b5132 8596 else
e9e44622 8597 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8598 return buff;
8599 }
8600}
8601
d1133906 8602static const char *
d3ba0551 8603get_symbol_type (unsigned int type)
252b5132 8604{
b34976b6 8605 static char buff[32];
252b5132
RH		 8606
8607 switch (type)
8608 {
b34976b6
AM		 8609 case STT_NOTYPE: return "NOTYPE";
8610 case STT_OBJECT: return "OBJECT";
8611 case STT_FUNC: return "FUNC";
8612 case STT_SECTION: return "SECTION";
8613 case STT_FILE: return "FILE";
8614 case STT_COMMON: return "COMMON";
8615 case STT_TLS: return "TLS";
15ab5209
DB		 8616 case STT_RELC: return "RELC";
8617 case STT_SRELC: return "SRELC";
252b5132
RH		 8618 default:
8619 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8620 {
8621 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8622 return "THUMB_FUNC";
8623
351b4b40 8624 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8625 return "REGISTER";
8626
8627 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8628 return "PARISC_MILLI";
8629
e9e44622 8630 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8631 }
252b5132 8632 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8633 {
8634 if (elf_header.e_machine == EM_PARISC)
8635 {
8636 if (type == STT_HP_OPAQUE)
8637 return "HP_OPAQUE";
8638 if (type == STT_HP_STUB)
8639 return "HP_STUB";
8640 }
8641
d8045f23
NC		 8642 if (type == STT_GNU_IFUNC
8643 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8644 /* GNU/Linux is still using the default value 0. */
8645 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8646 return "IFUNC";
8647
e9e44622 8648 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8649 }
252b5132 8650 else
e9e44622 8651 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8652 return buff;
8653 }
8654}
8655
d1133906 8656static const char *
d3ba0551 8657get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8658{
8659 switch (visibility)
8660 {
b34976b6
AM		 8661 case STV_DEFAULT: return "DEFAULT";
8662 case STV_INTERNAL: return "INTERNAL";
8663 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8664 case STV_PROTECTED: return "PROTECTED";
8665 default: abort ();
8666 }
8667}
8668
5e2b0d47
NC		 8669static const char *
8670get_mips_symbol_other (unsigned int other)
8671{
8672 switch (other)
8673 {
8674 case STO_OPTIONAL: return "OPTIONAL";
8675 case STO_MIPS16: return "MIPS16";
861fb55a
DJ		 8676 case STO_MIPS_PLT: return "MIPS PLT";
8677 case STO_MIPS_PIC: return "MIPS PIC";
5e2b0d47
NC		 8678 default: return NULL;
8679 }
8680}
8681
28f997cf
TG		 8682static const char *
8683get_ia64_symbol_other (unsigned int other)
8684{
8685 if (is_ia64_vms ())
8686 {
8687 static char res[32];
8688
8689 res[0] = 0;
8690
8691 /* Function types is for images and .STB files only. */
8692 switch (elf_header.e_type)
8693 {
8694 case ET_DYN:
8695 case ET_EXEC:
8696 switch (VMS_ST_FUNC_TYPE (other))
8697 {
8698 case VMS_SFT_CODE_ADDR:
8699 strcat (res, " CA");
8700 break;
8701 case VMS_SFT_SYMV_IDX:
8702 strcat (res, " VEC");
8703 break;
8704 case VMS_SFT_FD:
8705 strcat (res, " FD");
8706 break;
8707 case VMS_SFT_RESERVE:
8708 strcat (res, " RSV");
8709 break;
8710 default:
8711 abort ();
8712 }
8713 break;
8714 default:
8715 break;
8716 }
8717 switch (VMS_ST_LINKAGE (other))
8718 {
8719 case VMS_STL_IGNORE:
8720 strcat (res, " IGN");
8721 break;
8722 case VMS_STL_RESERVE:
8723 strcat (res, " RSV");
8724 break;
8725 case VMS_STL_STD:
8726 strcat (res, " STD");
8727 break;
8728 case VMS_STL_LNK:
8729 strcat (res, " LNK");
8730 break;
8731 default:
8732 abort ();
8733 }
8734
8735 if (res[0] != 0)
8736 return res + 1;
8737 else
8738 return res;
8739 }
8740 return NULL;
8741}
8742
5e2b0d47
NC		 8743static const char *
8744get_symbol_other (unsigned int other)
8745{
8746 const char * result = NULL;
8747 static char buff [32];
8748
8749 if (other == 0)
8750 return "";
8751
8752 switch (elf_header.e_machine)
8753 {
8754 case EM_MIPS:
8755 result = get_mips_symbol_other (other);
28f997cf
TG		 8756 break;
8757 case EM_IA_64:
8758 result = get_ia64_symbol_other (other);
8759 break;
5e2b0d47
NC		 8760 default:
8761 break;
8762 }
8763
8764 if (result)
8765 return result;
8766
8767 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8768 return buff;
8769}
8770
d1133906 8771static const char *
d3ba0551 8772get_symbol_index_type (unsigned int type)
252b5132 8773{
b34976b6 8774 static char buff[32];
5cf1065c 8775
252b5132
RH		 8776 switch (type)
8777 {
b34976b6
AM		 8778 case SHN_UNDEF: return "UND";
8779 case SHN_ABS: return "ABS";
8780 case SHN_COMMON: return "COM";
252b5132 8781 default:
9ce701e2
L		 8782 if (type == SHN_IA_64_ANSI_COMMON
8783 && elf_header.e_machine == EM_IA_64
8784 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8785 return "ANSI_COM";
8a9036a4
L		 8786 else if ((elf_header.e_machine == EM_X86_64
8787 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 8788 && type == SHN_X86_64_LCOMMON)
8789 return "LARGE_COM";
ac145307
BS		 8790 else if ((type == SHN_MIPS_SCOMMON
8791 && elf_header.e_machine == EM_MIPS)
8792 || (type == SHN_TIC6X_SCOMMON
8793 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8794 return "SCOM";
8795 else if (type == SHN_MIPS_SUNDEFINED
8796 && elf_header.e_machine == EM_MIPS)
8797 return "SUND";
9ce701e2 8798 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8799 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8800 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8801 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8802 else if (type >= SHN_LORESERVE)
8803 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8804 else
232e7cb8 8805 sprintf (buff, "%3d", type);
5cf1065c 8806 break;
252b5132 8807 }
5cf1065c
NC		 8808
8809 return buff;
252b5132
RH		 8810}
8811
66543521 8812static bfd_vma *
2cf0635d 8813get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8814{
2cf0635d
NC		 8815 unsigned char * e_data;
8816 bfd_vma * i_data;
252b5132 8817
3f5e193b 8818 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8819
8820 if (e_data == NULL)
8821 {
8822 error (_("Out of memory\n"));
8823 return NULL;
8824 }
8825
66543521 8826 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8827 {
8828 error (_("Unable to read in dynamic data\n"));
8829 return NULL;
8830 }
8831
3f5e193b 8832 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8833
8834 if (i_data == NULL)
8835 {
8836 error (_("Out of memory\n"));
8837 free (e_data);
8838 return NULL;
8839 }
8840
8841 while (number--)
66543521 8842 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8843
8844 free (e_data);
8845
8846 return i_data;
8847}
8848
6bd1a22c
L		 8849static void
8850print_dynamic_symbol (bfd_vma si, unsigned long hn)
8851{
2cf0635d 8852 Elf_Internal_Sym * psym;
6bd1a22c
L		 8853 int n;
8854
8855 psym = dynamic_symbols + si;
8856
8857 n = print_vma (si, DEC_5);
8858 if (n < 5)
8859 fputs (" " + n, stdout);
8860 printf (" %3lu: ", hn);
8861 print_vma (psym->st_value, LONG_HEX);
8862 putchar (' ');
8863 print_vma (psym->st_size, DEC_5);
8864
f4be36b3
AM		 8865 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8866 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8867 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8868 /* Check to see if any other bits in the st_other field are set.
8869 Note - displaying this information disrupts the layout of the
8870 table being generated, but for the moment this case is very
8871 rare. */
8872 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8873 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8874 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8875 if (VALID_DYNAMIC_NAME (psym->st_name))
8876 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8877 else
2b692964 8878 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8879 putchar ('\n');
8880}
8881
e3c8793a 8882/* Dump the symbol table. */
252b5132 8883static int
2cf0635d 8884process_symbol_table (FILE * file)
252b5132 8885{
2cf0635d 8886 Elf_Internal_Shdr * section;
66543521
AM		 8887 bfd_vma nbuckets = 0;
8888 bfd_vma nchains = 0;
2cf0635d
NC		 8889 bfd_vma * buckets = NULL;
8890 bfd_vma * chains = NULL;
fdc90cb4 8891 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8892 bfd_vma * gnubuckets = NULL;
8893 bfd_vma * gnuchains = NULL;
6bd1a22c 8894 bfd_vma gnusymidx = 0;
252b5132 8895
2c610e4b 8896 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8897 return 1;
8898
6bd1a22c
L		 8899 if (dynamic_info[DT_HASH]
8900 && (do_histogram
2c610e4b
L		 8901 || (do_using_dynamic
8902 && !do_dyn_syms
8903 && dynamic_strings != NULL)))
252b5132 8904 {
66543521
AM		 8905 unsigned char nb[8];
8906 unsigned char nc[8];
8907 int hash_ent_size = 4;
8908
8909 if ((elf_header.e_machine == EM_ALPHA
8910 || elf_header.e_machine == EM_S390
8911 || elf_header.e_machine == EM_S390_OLD)
8912 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8913 hash_ent_size = 8;
8914
fb52b2f4
NC		 8915 if (fseek (file,
8916 (archive_file_offset
8917 + offset_from_vma (file, dynamic_info[DT_HASH],
8918 sizeof nb + sizeof nc)),
d93f0186 8919 SEEK_SET))
252b5132 8920 {
591a748a 8921 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8922 goto no_hash;
252b5132
RH		 8923 }
8924
66543521 8925 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8926 {
8927 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8928 goto no_hash;
252b5132
RH		 8929 }
8930
66543521 8931 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8932 {
8933 error (_("Failed to read in number of chains\n"));
d3a44ec6 8934 goto no_hash;
252b5132
RH		 8935 }
8936
66543521
AM		 8937 nbuckets = byte_get (nb, hash_ent_size);
8938 nchains = byte_get (nc, hash_ent_size);
252b5132 8939
66543521
AM		 8940 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8941 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8942
d3a44ec6 8943 no_hash:
252b5132 8944 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8945 {
8946 if (do_using_dynamic)
8947 return 0;
8948 free (buckets);
8949 free (chains);
8950 buckets = NULL;
8951 chains = NULL;
8952 nbuckets = 0;
8953 nchains = 0;
8954 }
252b5132
RH		 8955 }
8956
6bd1a22c
L		 8957 if (dynamic_info_DT_GNU_HASH
8958 && (do_histogram
2c610e4b
L		 8959 || (do_using_dynamic
8960 && !do_dyn_syms
8961 && dynamic_strings != NULL)))
252b5132 8962 {
6bd1a22c
L		 8963 unsigned char nb[16];
8964 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8965 bfd_vma buckets_vma;
8966
8967 if (fseek (file,
8968 (archive_file_offset
8969 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8970 sizeof nb)),
8971 SEEK_SET))
8972 {
8973 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8974 goto no_gnu_hash;
6bd1a22c 8975 }
252b5132 8976
6bd1a22c
L		 8977 if (fread (nb, 16, 1, file) != 1)
8978 {
8979 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8980 goto no_gnu_hash;
6bd1a22c
L		 8981 }
8982
8983 ngnubuckets = byte_get (nb, 4);
8984 gnusymidx = byte_get (nb + 4, 4);
8985 bitmaskwords = byte_get (nb + 8, 4);
8986 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 8987 if (is_32bit_elf)
6bd1a22c 8988 buckets_vma += bitmaskwords * 4;
f7a99963 8989 else
6bd1a22c 8990 buckets_vma += bitmaskwords * 8;
252b5132 8991
6bd1a22c
L		 8992 if (fseek (file,
8993 (archive_file_offset
8994 + offset_from_vma (file, buckets_vma, 4)),
8995 SEEK_SET))
252b5132 8996 {
6bd1a22c 8997 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8998 goto no_gnu_hash;
6bd1a22c
L		 8999 }
9000
9001 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9002
6bd1a22c 9003 if (gnubuckets == NULL)
d3a44ec6 9004 goto no_gnu_hash;
6bd1a22c
L		 9005
9006 for (i = 0; i < ngnubuckets; i++)
9007 if (gnubuckets[i] != 0)
9008 {
9009 if (gnubuckets[i] < gnusymidx)
9010 return 0;
9011
9012 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9013 maxchain = gnubuckets[i];
9014 }
9015
9016 if (maxchain == 0xffffffff)
d3a44ec6 9017 goto no_gnu_hash;
6bd1a22c
L		 9018
9019 maxchain -= gnusymidx;
9020
9021 if (fseek (file,
9022 (archive_file_offset
9023 + offset_from_vma (file, buckets_vma
9024 + 4 * (ngnubuckets + maxchain), 4)),
9025 SEEK_SET))
9026 {
9027 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9028 goto no_gnu_hash;
6bd1a22c
L		 9029 }
9030
9031 do
9032 {
9033 if (fread (nb, 4, 1, file) != 1)
252b5132 9034 {
6bd1a22c 9035 error (_("Failed to determine last chain length\n"));
d3a44ec6 9036 goto no_gnu_hash;
6bd1a22c 9037 }
252b5132 9038
6bd1a22c 9039 if (maxchain + 1 == 0)
d3a44ec6 9040 goto no_gnu_hash;
252b5132 9041
6bd1a22c
L		 9042 ++maxchain;
9043 }
9044 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9045
6bd1a22c
L		 9046 if (fseek (file,
9047 (archive_file_offset
9048 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9049 SEEK_SET))
9050 {
9051 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9052 goto no_gnu_hash;
6bd1a22c
L		 9053 }
9054
9055 gnuchains = get_dynamic_data (file, maxchain, 4);
9056
d3a44ec6 9057 no_gnu_hash:
6bd1a22c 9058 if (gnuchains == NULL)
d3a44ec6
JJ		 9059 {
9060 free (gnubuckets);
d3a44ec6
JJ		 9061 gnubuckets = NULL;
9062 ngnubuckets = 0;
f64fddf1
NC		 9063 if (do_using_dynamic)
9064 return 0;
d3a44ec6 9065 }
6bd1a22c
L		 9066 }
9067
9068 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9069 && do_syms
9070 && do_using_dynamic
9071 && dynamic_strings != NULL)
9072 {
9073 unsigned long hn;
9074
9075 if (dynamic_info[DT_HASH])
9076 {
9077 bfd_vma si;
9078
9079 printf (_("\nSymbol table for image:\n"));
9080 if (is_32bit_elf)
9081 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9082 else
9083 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9084
9085 for (hn = 0; hn < nbuckets; hn++)
9086 {
9087 if (! buckets[hn])
9088 continue;
9089
9090 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9091 print_dynamic_symbol (si, hn);
252b5132
RH		 9092 }
9093 }
6bd1a22c
L		 9094
9095 if (dynamic_info_DT_GNU_HASH)
9096 {
9097 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9098 if (is_32bit_elf)
9099 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9100 else
9101 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9102
9103 for (hn = 0; hn < ngnubuckets; ++hn)
9104 if (gnubuckets[hn] != 0)
9105 {
9106 bfd_vma si = gnubuckets[hn];
9107 bfd_vma off = si - gnusymidx;
9108
9109 do
9110 {
9111 print_dynamic_symbol (si, hn);
9112 si++;
9113 }
9114 while ((gnuchains[off++] & 1) == 0);
9115 }
9116 }
252b5132 9117 }
2c610e4b 9118 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9119 {
b34976b6 9120 unsigned int i;
252b5132
RH		 9121
9122 for (i = 0, section = section_headers;
9123 i < elf_header.e_shnum;
9124 i++, section++)
9125 {
b34976b6 9126 unsigned int si;
2cf0635d 9127 char * strtab = NULL;
c256ffe7 9128 unsigned long int strtab_size = 0;
2cf0635d
NC		 9129 Elf_Internal_Sym * symtab;
9130 Elf_Internal_Sym * psym;
252b5132 9131
2c610e4b
L		 9132 if ((section->sh_type != SHT_SYMTAB
9133 && section->sh_type != SHT_DYNSYM)
9134 || (!do_syms
9135 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9136 continue;
9137
dd24e3da
NC		 9138 if (section->sh_entsize == 0)
9139 {
9140 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9141 SECTION_NAME (section));
9142 continue;
9143 }
9144
252b5132
RH		 9145 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9146 SECTION_NAME (section),
9147 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9148
f7a99963 9149 if (is_32bit_elf)
ca47b30c 9150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9151 else
ca47b30c 9152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9153
9ad5cbcf 9154 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 9155 if (symtab == NULL)
9156 continue;
9157
9158 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9159 {
9160 strtab = string_table;
9161 strtab_size = string_table_length;
9162 }
4fbb74a6 9163 else if (section->sh_link < elf_header.e_shnum)
252b5132 9164 {
2cf0635d 9165 Elf_Internal_Shdr * string_sec;
252b5132 9166
4fbb74a6 9167 string_sec = section_headers + section->sh_link;
252b5132 9168
3f5e193b
NC		 9169 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9170 1, string_sec->sh_size,
9171 _("string table"));
c256ffe7 9172 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9173 }
9174
9175 for (si = 0, psym = symtab;
9176 si < section->sh_size / section->sh_entsize;
b34976b6 9177 si++, psym++)
252b5132 9178 {
5e220199 9179 printf ("%6d: ", si);
f7a99963
NC		 9180 print_vma (psym->st_value, LONG_HEX);
9181 putchar (' ');
9182 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9183 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9184 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9185 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9186 /* Check to see if any other bits in the st_other field are set.
9187 Note - displaying this information disrupts the layout of the
9188 table being generated, but for the moment this case is very rare. */
9189 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9190 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9191 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9192 print_symbol (25, psym->st_name < strtab_size
2b692964 9193 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9194
59245841
NC		 9195 if (section->sh_type == SHT_DYNSYM
9196 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9197 {
b34976b6
AM		 9198 unsigned char data[2];
9199 unsigned short vers_data;
9200 unsigned long offset;
9201 int is_nobits;
9202 int check_def;
252b5132 9203
d93f0186
NC		 9204 offset = offset_from_vma
9205 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9206 sizeof data + si * sizeof (vers_data));
252b5132 9207
59245841
NC		 9208 if (get_data (&data, file, offset + si * sizeof (vers_data),
9209 sizeof (data), 1, _("version data")) == NULL)
9210 break;
252b5132
RH		 9211
9212 vers_data = byte_get (data, 2);
9213
4fbb74a6
AM		 9214 is_nobits = (psym->st_shndx < elf_header.e_shnum
9215 && section_headers[psym->st_shndx].sh_type
c256ffe7 9216 == SHT_NOBITS);
252b5132
RH		 9217
9218 check_def = (psym->st_shndx != SHN_UNDEF);
9219
c244d050 9220 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9221 {
b34976b6 9222 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9223 && (is_nobits || ! check_def))
252b5132 9224 {
b34976b6
AM		 9225 Elf_External_Verneed evn;
9226 Elf_Internal_Verneed ivn;
9227 Elf_Internal_Vernaux ivna;
252b5132
RH		 9228
9229 /* We must test both. */
d93f0186
NC		 9230 offset = offset_from_vma
9231 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9232 sizeof evn);
252b5132 9233
252b5132
RH		 9234 do
9235 {
b34976b6 9236 unsigned long vna_off;
252b5132 9237
59245841
NC		 9238 if (get_data (&evn, file, offset, sizeof (evn), 1,
9239 _("version need")) == NULL)
9240 {
9241 ivna.vna_next = 0;
9242 ivna.vna_other = 0;
9243 ivna.vna_name = 0;
9244 break;
9245 }
dd27201e
L		 9246
9247 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9248 ivn.vn_next = BYTE_GET (evn.vn_next);
9249
252b5132
RH		 9250 vna_off = offset + ivn.vn_aux;
9251
9252 do
9253 {
b34976b6 9254 Elf_External_Vernaux evna;
252b5132 9255
59245841
NC		 9256 if (get_data (&evna, file, vna_off,
9257 sizeof (evna), 1,
9258 _("version need aux (3)")) == NULL)
9259 {
9260 ivna.vna_next = 0;
9261 ivna.vna_other = 0;
9262 ivna.vna_name = 0;
9263 }
9264 else
9265 {
9266 ivna.vna_other = BYTE_GET (evna.vna_other);
9267 ivna.vna_next = BYTE_GET (evna.vna_next);
9268 ivna.vna_name = BYTE_GET (evna.vna_name);
9269 }
252b5132
RH		 9270
9271 vna_off += ivna.vna_next;
9272 }
9273 while (ivna.vna_other != vers_data
9274 && ivna.vna_next != 0);
9275
9276 if (ivna.vna_other == vers_data)
9277 break;
9278
9279 offset += ivn.vn_next;
9280 }
9281 while (ivn.vn_next != 0);
9282
9283 if (ivna.vna_other == vers_data)
9284 {
9285 printf ("@%s (%d)",
c256ffe7 9286 ivna.vna_name < strtab_size
2b692964 9287 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9288 ivna.vna_other);
252b5132
RH		 9289 check_def = 0;
9290 }
9291 else if (! is_nobits)
591a748a 9292 error (_("bad dynamic symbol\n"));
252b5132
RH		 9293 else
9294 check_def = 1;
9295 }
9296
9297 if (check_def)
9298 {
00d93f34 9299 if (vers_data != 0x8001
b34976b6 9300 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9301 {
b34976b6
AM		 9302 Elf_Internal_Verdef ivd;
9303 Elf_Internal_Verdaux ivda;
9304 Elf_External_Verdaux evda;
91d6fa6a 9305 unsigned long off;
252b5132 9306
91d6fa6a 9307 off = offset_from_vma
d93f0186
NC		 9308 (file,
9309 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9310 sizeof (Elf_External_Verdef));
252b5132
RH		 9311
9312 do
9313 {
b34976b6 9314 Elf_External_Verdef evd;
252b5132 9315
59245841
NC		 9316 if (get_data (&evd, file, off, sizeof (evd),
9317 1, _("version def")) == NULL)
9318 {
9319 ivd.vd_ndx = 0;
9320 ivd.vd_aux = 0;
9321 ivd.vd_next = 0;
9322 }
9323 else
9324 {
9325 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9326 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9327 ivd.vd_next = BYTE_GET (evd.vd_next);
9328 }
252b5132 9329
91d6fa6a 9330 off += ivd.vd_next;
252b5132 9331 }
c244d050 9332 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9333 && ivd.vd_next != 0);
9334
91d6fa6a
NC		 9335 off -= ivd.vd_next;
9336 off += ivd.vd_aux;
252b5132 9337
59245841
NC		 9338 if (get_data (&evda, file, off, sizeof (evda),
9339 1, _("version def aux")) == NULL)
9340 break;
252b5132
RH		 9341
9342 ivda.vda_name = BYTE_GET (evda.vda_name);
9343
9344 if (psym->st_name != ivda.vda_name)
c244d050 9345 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9346 ? "@%s" : "@@%s",
c256ffe7 9347 ivda.vda_name < strtab_size
2b692964 9348 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9349 }
9350 }
9351 }
9352 }
9353
9354 putchar ('\n');
9355 }
9356
9357 free (symtab);
9358 if (strtab != string_table)
9359 free (strtab);
9360 }
9361 }
9362 else if (do_syms)
9363 printf
9364 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9365
9366 if (do_histogram && buckets != NULL)
9367 {
2cf0635d
NC		 9368 unsigned long * lengths;
9369 unsigned long * counts;
66543521
AM		 9370 unsigned long hn;
9371 bfd_vma si;
9372 unsigned long maxlength = 0;
9373 unsigned long nzero_counts = 0;
9374 unsigned long nsyms = 0;
252b5132 9375
66543521
AM		 9376 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9377 (unsigned long) nbuckets);
252b5132
RH		 9378 printf (_(" Length Number %% of total Coverage\n"));
9379
3f5e193b 9380 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9381 if (lengths == NULL)
9382 {
591a748a 9383 error (_("Out of memory\n"));
252b5132
RH		 9384 return 0;
9385 }
9386 for (hn = 0; hn < nbuckets; ++hn)
9387 {
f7a99963 9388 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9389 {
b34976b6 9390 ++nsyms;
252b5132 9391 if (maxlength < ++lengths[hn])
b34976b6 9392 ++maxlength;
252b5132
RH		 9393 }
9394 }
9395
3f5e193b 9396 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9397 if (counts == NULL)
9398 {
591a748a 9399 error (_("Out of memory\n"));
252b5132
RH		 9400 return 0;
9401 }
9402
9403 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9404 ++counts[lengths[hn]];
252b5132 9405
103f02d3 9406 if (nbuckets > 0)
252b5132 9407 {
66543521
AM		 9408 unsigned long i;
9409 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9410 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9411 for (i = 1; i <= maxlength; ++i)
103f02d3 9412 {
66543521
AM		 9413 nzero_counts += counts[i] * i;
9414 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9415 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9416 (nzero_counts * 100.0) / nsyms);
9417 }
252b5132
RH		 9418 }
9419
9420 free (counts);
9421 free (lengths);
9422 }
9423
9424 if (buckets != NULL)
9425 {
9426 free (buckets);
9427 free (chains);
9428 }
9429
d3a44ec6 9430 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9431 {
2cf0635d
NC		 9432 unsigned long * lengths;
9433 unsigned long * counts;
fdc90cb4
JJ		 9434 unsigned long hn;
9435 unsigned long maxlength = 0;
9436 unsigned long nzero_counts = 0;
9437 unsigned long nsyms = 0;
fdc90cb4 9438
3f5e193b 9439 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9440 if (lengths == NULL)
9441 {
591a748a 9442 error (_("Out of memory\n"));
fdc90cb4
JJ		 9443 return 0;
9444 }
9445
9446 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9447 (unsigned long) ngnubuckets);
9448 printf (_(" Length Number %% of total Coverage\n"));
9449
9450 for (hn = 0; hn < ngnubuckets; ++hn)
9451 if (gnubuckets[hn] != 0)
9452 {
9453 bfd_vma off, length = 1;
9454
6bd1a22c 9455 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9456 (gnuchains[off] & 1) == 0; ++off)
9457 ++length;
9458 lengths[hn] = length;
9459 if (length > maxlength)
9460 maxlength = length;
9461 nsyms += length;
9462 }
9463
3f5e193b 9464 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9465 if (counts == NULL)
9466 {
591a748a 9467 error (_("Out of memory\n"));
fdc90cb4
JJ		 9468 return 0;
9469 }
9470
9471 for (hn = 0; hn < ngnubuckets; ++hn)
9472 ++counts[lengths[hn]];
9473
9474 if (ngnubuckets > 0)
9475 {
9476 unsigned long j;
9477 printf (" 0 %-10lu (%5.1f%%)\n",
9478 counts[0], (counts[0] * 100.0) / ngnubuckets);
9479 for (j = 1; j <= maxlength; ++j)
9480 {
9481 nzero_counts += counts[j] * j;
9482 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9483 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9484 (nzero_counts * 100.0) / nsyms);
9485 }
9486 }
9487
9488 free (counts);
9489 free (lengths);
9490 free (gnubuckets);
9491 free (gnuchains);
9492 }
9493
252b5132
RH		 9494 return 1;
9495}
9496
9497static int
2cf0635d 9498process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9499{
b4c96d0d 9500 unsigned int i;
252b5132
RH		 9501
9502 if (dynamic_syminfo == NULL
9503 || !do_dynamic)
9504 /* No syminfo, this is ok. */
9505 return 1;
9506
9507 /* There better should be a dynamic symbol section. */
9508 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9509 return 0;
9510
9511 if (dynamic_addr)
9512 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9513 dynamic_syminfo_offset, dynamic_syminfo_nent);
9514
9515 printf (_(" Num: Name BoundTo Flags\n"));
9516 for (i = 0; i < dynamic_syminfo_nent; ++i)
9517 {
9518 unsigned short int flags = dynamic_syminfo[i].si_flags;
9519
31104126 9520 printf ("%4d: ", i);
d79b3d50
NC		 9521 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9522 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9523 else
2b692964 9524 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9525 putchar (' ');
252b5132
RH		 9526
9527 switch (dynamic_syminfo[i].si_boundto)
9528 {
9529 case SYMINFO_BT_SELF:
9530 fputs ("SELF ", stdout);
9531 break;
9532 case SYMINFO_BT_PARENT:
9533 fputs ("PARENT ", stdout);
9534 break;
9535 default:
9536 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9537 && dynamic_syminfo[i].si_boundto < dynamic_nent
9538 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9539 {
d79b3d50 9540 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9541 putchar (' ' );
9542 }
252b5132
RH		 9543 else
9544 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9545 break;
9546 }
9547
9548 if (flags & SYMINFO_FLG_DIRECT)
9549 printf (" DIRECT");
9550 if (flags & SYMINFO_FLG_PASSTHRU)
9551 printf (" PASSTHRU");
9552 if (flags & SYMINFO_FLG_COPY)
9553 printf (" COPY");
9554 if (flags & SYMINFO_FLG_LAZYLOAD)
9555 printf (" LAZYLOAD");
9556
9557 puts ("");
9558 }
9559
9560 return 1;
9561}
9562
cf13d699
NC		 9563/* Check to see if the given reloc needs to be handled in a target specific
9564 manner. If so then process the reloc and return TRUE otherwise return
9565 FALSE. */
09c11c86 9566
cf13d699
NC		 9567static bfd_boolean
9568target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9569 unsigned char * start,
9570 Elf_Internal_Sym * symtab)
252b5132 9571{
cf13d699 9572 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9573
cf13d699 9574 switch (elf_header.e_machine)
252b5132 9575 {
cf13d699
NC		 9576 case EM_MN10300:
9577 case EM_CYGNUS_MN10300:
9578 {
9579 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9580
cf13d699
NC		 9581 switch (reloc_type)
9582 {
9583 case 34: /* R_MN10300_ALIGN */
9584 return TRUE;
9585 case 33: /* R_MN10300_SYM_DIFF */
9586 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9587 return TRUE;
9588 case 1: /* R_MN10300_32 */
9589 case 2: /* R_MN10300_16 */
9590 if (saved_sym != NULL)
9591 {
9592 bfd_vma value;
252b5132 9593
cf13d699
NC		 9594 value = reloc->r_addend
9595 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9596 - saved_sym->st_value);
252b5132 9597
cf13d699 9598 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9599
cf13d699
NC		 9600 saved_sym = NULL;
9601 return TRUE;
9602 }
9603 break;
9604 default:
9605 if (saved_sym != NULL)
9606 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9607 break;
9608 }
9609 break;
9610 }
252b5132
RH		 9611 }
9612
cf13d699 9613 return FALSE;
252b5132
RH		 9614}
9615
aca88567
NC		 9616/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9617 DWARF debug sections. This is a target specific test. Note - we do not
9618 go through the whole including-target-headers-multiple-times route, (as
9619 we have already done with <elf/h8.h>) because this would become very
9620 messy and even then this function would have to contain target specific
9621 information (the names of the relocs instead of their numeric values).
9622 FIXME: This is not the correct way to solve this problem. The proper way
9623 is to have target specific reloc sizing and typing functions created by
9624 the reloc-macros.h header, in the same way that it already creates the
9625 reloc naming functions. */
9626
9627static bfd_boolean
9628is_32bit_abs_reloc (unsigned int reloc_type)
9629{
9630 switch (elf_header.e_machine)
9631 {
41e92641
NC		 9632 case EM_386:
9633 case EM_486:
9634 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9635 case EM_68K:
9636 return reloc_type == 1; /* R_68K_32. */
9637 case EM_860:
9638 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9639 case EM_960:
9640 return reloc_type == 2; /* R_960_32. */
aca88567 9641 case EM_ALPHA:
137b6b5f 9642 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9643 case EM_ARC:
9644 return reloc_type == 1; /* R_ARC_32. */
9645 case EM_ARM:
9646 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9647 case EM_AVR_OLD:
aca88567
NC		 9648 case EM_AVR:
9649 return reloc_type == 1;
9650 case EM_BLACKFIN:
9651 return reloc_type == 0x12; /* R_byte4_data. */
9652 case EM_CRIS:
9653 return reloc_type == 3; /* R_CRIS_32. */
9654 case EM_CR16:
6c03b1ed 9655 case EM_CR16_OLD:
aca88567
NC		 9656 return reloc_type == 3; /* R_CR16_NUM32. */
9657 case EM_CRX:
9658 return reloc_type == 15; /* R_CRX_NUM32. */
9659 case EM_CYGNUS_FRV:
9660 return reloc_type == 1;
41e92641
NC		 9661 case EM_CYGNUS_D10V:
9662 case EM_D10V:
9663 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9664 case EM_CYGNUS_D30V:
9665 case EM_D30V:
9666 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9667 case EM_DLX:
9668 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9669 case EM_CYGNUS_FR30:
9670 case EM_FR30:
9671 return reloc_type == 3; /* R_FR30_32. */
9672 case EM_H8S:
9673 case EM_H8_300:
9674 case EM_H8_300H:
9675 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9676 case EM_IA_64:
9677 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9678 case EM_IP2K_OLD:
9679 case EM_IP2K:
9680 return reloc_type == 2; /* R_IP2K_32. */
9681 case EM_IQ2000:
9682 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9683 case EM_LATTICEMICO32:
9684 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9685 case EM_M32C_OLD:
aca88567
NC		 9686 case EM_M32C:
9687 return reloc_type == 3; /* R_M32C_32. */
9688 case EM_M32R:
9689 return reloc_type == 34; /* R_M32R_32_RELA. */
9690 case EM_MCORE:
9691 return reloc_type == 1; /* R_MCORE_ADDR32. */
9692 case EM_CYGNUS_MEP:
9693 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9694 case EM_MICROBLAZE:
9695 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9696 case EM_MIPS:
9697 return reloc_type == 2; /* R_MIPS_32. */
9698 case EM_MMIX:
9699 return reloc_type == 4; /* R_MMIX_32. */
9700 case EM_CYGNUS_MN10200:
9701 case EM_MN10200:
9702 return reloc_type == 1; /* R_MN10200_32. */
9703 case EM_CYGNUS_MN10300:
9704 case EM_MN10300:
9705 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9706 case EM_MOXIE:
9707 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9708 case EM_MSP430_OLD:
9709 case EM_MSP430:
9710 return reloc_type == 1; /* R_MSP43_32. */
9711 case EM_MT:
9712 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9713 case EM_ALTERA_NIOS2:
9714 case EM_NIOS32:
9715 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9716 case EM_OPENRISC:
9717 case EM_OR32:
9718 return reloc_type == 1; /* R_OR32_32. */
aca88567 9719 case EM_PARISC:
5fda8eca
NC		 9720 return (reloc_type == 1 /* R_PARISC_DIR32. */
9721 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9722 case EM_PJ:
9723 case EM_PJ_OLD:
9724 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9725 case EM_PPC64:
9726 return reloc_type == 1; /* R_PPC64_ADDR32. */
9727 case EM_PPC:
9728 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9729 case EM_RX:
9730 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9731 case EM_S370:
9732 return reloc_type == 1; /* R_I370_ADDR31. */
9733 case EM_S390_OLD:
9734 case EM_S390:
9735 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9736 case EM_SCORE:
9737 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9738 case EM_SH:
9739 return reloc_type == 1; /* R_SH_DIR32. */
9740 case EM_SPARC32PLUS:
9741 case EM_SPARCV9:
9742 case EM_SPARC:
9743 return reloc_type == 3 /* R_SPARC_32. */
9744 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9745 case EM_SPU:
9746 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9747 case EM_TI_C6000:
9748 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9749 case EM_TILEGX:
9750 return reloc_type == 2; /* R_TILEGX_32. */
9751 case EM_TILEPRO:
9752 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9753 case EM_CYGNUS_V850:
9754 case EM_V850:
9755 return reloc_type == 6; /* R_V850_ABS32. */
9756 case EM_VAX:
9757 return reloc_type == 1; /* R_VAX_32. */
9758 case EM_X86_64:
8a9036a4 9759 case EM_L1OM:
aca88567 9760 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9761 case EM_XC16X:
9762 case EM_C166:
9763 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9764 case EM_XSTORMY16:
9765 return reloc_type == 1; /* R_XSTROMY16_32. */
9766 case EM_XTENSA_OLD:
9767 case EM_XTENSA:
9768 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9769 default:
9770 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9771 elf_header.e_machine);
9772 abort ();
9773 }
9774}
9775
9776/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9777 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9778
9779static bfd_boolean
9780is_32bit_pcrel_reloc (unsigned int reloc_type)
9781{
9782 switch (elf_header.e_machine)
9783 {
41e92641
NC		 9784 case EM_386:
9785 case EM_486:
3e0873ac 9786 return reloc_type == 2; /* R_386_PC32. */
aca88567 9787 case EM_68K:
3e0873ac 9788 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9789 case EM_ALPHA:
9790 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9791 case EM_ARM:
3e0873ac 9792 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9793 case EM_MICROBLAZE:
9794 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9795 case EM_PARISC:
85acf597 9796 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9797 case EM_PPC:
9798 return reloc_type == 26; /* R_PPC_REL32. */
9799 case EM_PPC64:
3e0873ac 9800 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9801 case EM_S390_OLD:
9802 case EM_S390:
3e0873ac 9803 return reloc_type == 5; /* R_390_PC32. */
aca88567 9804 case EM_SH:
3e0873ac 9805 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9806 case EM_SPARC32PLUS:
9807 case EM_SPARCV9:
9808 case EM_SPARC:
3e0873ac 9809 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9810 case EM_SPU:
9811 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9812 case EM_TILEGX:
9813 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9814 case EM_TILEPRO:
9815 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 9816 case EM_X86_64:
8a9036a4 9817 case EM_L1OM:
3e0873ac 9818 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9819 case EM_XTENSA_OLD:
9820 case EM_XTENSA:
9821 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9822 default:
9823 /* Do not abort or issue an error message here. Not all targets use
9824 pc-relative 32-bit relocs in their DWARF debug information and we
9825 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9826 more helpful warning message will be generated by apply_relocations
9827 anyway, so just return. */
aca88567
NC		 9828 return FALSE;
9829 }
9830}
9831
9832/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9833 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9834
9835static bfd_boolean
9836is_64bit_abs_reloc (unsigned int reloc_type)
9837{
9838 switch (elf_header.e_machine)
9839 {
9840 case EM_ALPHA:
9841 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9842 case EM_IA_64:
9843 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9844 case EM_PARISC:
9845 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9846 case EM_PPC64:
9847 return reloc_type == 38; /* R_PPC64_ADDR64. */
9848 case EM_SPARC32PLUS:
9849 case EM_SPARCV9:
9850 case EM_SPARC:
9851 return reloc_type == 54; /* R_SPARC_UA64. */
9852 case EM_X86_64:
8a9036a4 9853 case EM_L1OM:
aca88567 9854 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9855 case EM_S390_OLD:
9856 case EM_S390:
aa137e4d
NC		 9857 return reloc_type == 22; /* R_S390_64. */
9858 case EM_TILEGX:
9859 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 9860 case EM_MIPS:
aa137e4d 9861 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 9862 default:
9863 return FALSE;
9864 }
9865}
9866
85acf597
RH		 9867/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9868 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9869
9870static bfd_boolean
9871is_64bit_pcrel_reloc (unsigned int reloc_type)
9872{
9873 switch (elf_header.e_machine)
9874 {
9875 case EM_ALPHA:
aa137e4d 9876 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 9877 case EM_IA_64:
aa137e4d 9878 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 9879 case EM_PARISC:
aa137e4d 9880 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 9881 case EM_PPC64:
aa137e4d 9882 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 9883 case EM_SPARC32PLUS:
9884 case EM_SPARCV9:
9885 case EM_SPARC:
aa137e4d 9886 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 9887 case EM_X86_64:
8a9036a4 9888 case EM_L1OM:
aa137e4d 9889 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 9890 case EM_S390_OLD:
9891 case EM_S390:
aa137e4d
NC		 9892 return reloc_type == 23; /* R_S390_PC64. */
9893 case EM_TILEGX:
9894 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 9895 default:
9896 return FALSE;
9897 }
9898}
9899
4dc3c23d
AM		 9900/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9901 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9902
9903static bfd_boolean
9904is_24bit_abs_reloc (unsigned int reloc_type)
9905{
9906 switch (elf_header.e_machine)
9907 {
9908 case EM_CYGNUS_MN10200:
9909 case EM_MN10200:
9910 return reloc_type == 4; /* R_MN10200_24. */
9911 default:
9912 return FALSE;
9913 }
9914}
9915
aca88567
NC		 9916/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9917 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9918
9919static bfd_boolean
9920is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9921{
9922 switch (elf_header.e_machine)
9923 {
aca88567
NC		 9924 case EM_AVR_OLD:
9925 case EM_AVR:
9926 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9927 case EM_CYGNUS_D10V:
9928 case EM_D10V:
9929 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9930 case EM_H8S:
9931 case EM_H8_300:
9932 case EM_H8_300H:
aca88567
NC		 9933 return reloc_type == R_H8_DIR16;
9934 case EM_IP2K_OLD:
9935 case EM_IP2K:
9936 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9937 case EM_M32C_OLD:
f4236fe4
DD		 9938 case EM_M32C:
9939 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9940 case EM_MSP430_OLD:
9941 case EM_MSP430:
9942 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9943 case EM_ALTERA_NIOS2:
9944 case EM_NIOS32:
9945 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9946 case EM_TI_C6000:
9947 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9948 case EM_XC16X:
9949 case EM_C166:
9950 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9951 default:
aca88567 9952 return FALSE;
4b78141a
NC		 9953 }
9954}
9955
2a7b2e88
JK		 9956/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9957 relocation entries (possibly formerly used for SHT_GROUP sections). */
9958
9959static bfd_boolean
9960is_none_reloc (unsigned int reloc_type)
9961{
9962 switch (elf_header.e_machine)
9963 {
cb8f3167
NC		 9964 case EM_68K: /* R_68K_NONE. */
9965 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9966 case EM_SPARC32PLUS:
9967 case EM_SPARCV9:
cb8f3167
NC		 9968 case EM_SPARC: /* R_SPARC_NONE. */
9969 case EM_MIPS: /* R_MIPS_NONE. */
9970 case EM_PARISC: /* R_PARISC_NONE. */
9971 case EM_ALPHA: /* R_ALPHA_NONE. */
9972 case EM_PPC: /* R_PPC_NONE. */
9973 case EM_PPC64: /* R_PPC64_NONE. */
9974 case EM_ARM: /* R_ARM_NONE. */
9975 case EM_IA_64: /* R_IA64_NONE. */
9976 case EM_SH: /* R_SH_NONE. */
2a7b2e88 9977 case EM_S390_OLD:
cb8f3167
NC		 9978 case EM_S390: /* R_390_NONE. */
9979 case EM_CRIS: /* R_CRIS_NONE. */
9980 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 9981 case EM_L1OM: /* R_X86_64_NONE. */
cb8f3167 9982 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 9983 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 9984 case EM_M32R: /* R_M32R_NONE. */
40b36596 9985 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 9986 case EM_TILEGX: /* R_TILEGX_NONE. */
9987 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 9988 case EM_XC16X:
9989 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 9990 return reloc_type == 0;
58332dda
JK		 9991 case EM_XTENSA_OLD:
9992 case EM_XTENSA:
4dc3c23d
AM		 9993 return (reloc_type == 0 /* R_XTENSA_NONE. */
9994 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9995 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9996 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 9997 }
9998 return FALSE;
9999}
10000
cf13d699
NC		 10001/* Apply relocations to a section.
10002 Note: So far support has been added only for those relocations
10003 which can be found in debug sections.
10004 FIXME: Add support for more relocations ? */
1b315056 10005
cf13d699
NC		 10006static void
10007apply_relocations (void * file,
10008 Elf_Internal_Shdr * section,
10009 unsigned char * start)
1b315056 10010{
cf13d699
NC		 10011 Elf_Internal_Shdr * relsec;
10012 unsigned char * end = start + section->sh_size;
cb8f3167 10013
cf13d699
NC		 10014 if (elf_header.e_type != ET_REL)
10015 return;
1b315056 10016
cf13d699 10017 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10018 for (relsec = section_headers;
10019 relsec < section_headers + elf_header.e_shnum;
10020 ++relsec)
252b5132 10021 {
41e92641
NC		 10022 bfd_boolean is_rela;
10023 unsigned long num_relocs;
2cf0635d
NC		 10024 Elf_Internal_Rela * relocs;
10025 Elf_Internal_Rela * rp;
10026 Elf_Internal_Shdr * symsec;
10027 Elf_Internal_Sym * symtab;
10028 Elf_Internal_Sym * sym;
252b5132 10029
41e92641 10030 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10031 || relsec->sh_info >= elf_header.e_shnum
10032 || section_headers + relsec->sh_info != section
c256ffe7 10033 || relsec->sh_size == 0
4fbb74a6 10034 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10035 continue;
428409d5 10036
41e92641
NC		 10037 is_rela = relsec->sh_type == SHT_RELA;
10038
10039 if (is_rela)
10040 {
3f5e193b
NC		 10041 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10042 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10043 return;
10044 }
10045 else
10046 {
3f5e193b
NC		 10047 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10048 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10049 return;
10050 }
10051
10052 /* SH uses RELA but uses in place value instead of the addend field. */
10053 if (elf_header.e_machine == EM_SH)
10054 is_rela = FALSE;
428409d5 10055
4fbb74a6 10056 symsec = section_headers + relsec->sh_link;
3f5e193b 10057 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 10058
41e92641 10059 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10060 {
41e92641
NC		 10061 bfd_vma addend;
10062 unsigned int reloc_type;
10063 unsigned int reloc_size;
91d6fa6a 10064 unsigned char * rloc;
4b78141a 10065
aca88567 10066 reloc_type = get_reloc_type (rp->r_info);
41e92641 10067
98fb390a 10068 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10069 continue;
98fb390a
NC		 10070 else if (is_none_reloc (reloc_type))
10071 continue;
10072 else if (is_32bit_abs_reloc (reloc_type)
10073 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10074 reloc_size = 4;
85acf597
RH		 10075 else if (is_64bit_abs_reloc (reloc_type)
10076 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10077 reloc_size = 8;
4dc3c23d
AM		 10078 else if (is_24bit_abs_reloc (reloc_type))
10079 reloc_size = 3;
aca88567
NC		 10080 else if (is_16bit_abs_reloc (reloc_type))
10081 reloc_size = 2;
10082 else
4b78141a 10083 {
41e92641 10084 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10085 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10086 continue;
10087 }
103f02d3 10088
91d6fa6a
NC		 10089 rloc = start + rp->r_offset;
10090 if ((rloc + reloc_size) > end)
700dd8b7
L		 10091 {
10092 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10093 (unsigned long) rp->r_offset,
10094 SECTION_NAME (section));
10095 continue;
10096 }
103f02d3 10097
41e92641
NC		 10098 sym = symtab + get_reloc_symindex (rp->r_info);
10099
10100 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10101 make sure that it is of an appropriate type.
10102
10103 Relocations against symbols without type can happen.
10104 Gcc -feliminate-dwarf2-dups may generate symbols
10105 without type for debug info.
10106
10107 Icc generates relocations against function symbols
10108 instead of local labels.
10109
10110 Relocations against object symbols can happen, eg when
10111 referencing a global array. For an example of this see
10112 the _clz.o binary in libgcc.a. */
aca88567 10113 if (sym != symtab
55f25fc3 10114 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10115 {
41e92641 10116 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10117 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10118 (long int)(rp - relocs),
41e92641 10119 SECTION_NAME (relsec));
aca88567 10120 continue;
5b18a4bc 10121 }
252b5132 10122
4dc3c23d
AM		 10123 addend = 0;
10124 if (is_rela)
10125 addend += rp->r_addend;
c47320c3
AM		 10126 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10127 partial_inplace. */
4dc3c23d
AM		 10128 if (!is_rela
10129 || (elf_header.e_machine == EM_XTENSA
10130 && reloc_type == 1)
10131 || ((elf_header.e_machine == EM_PJ
10132 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10133 && reloc_type == 1)
10134 || ((elf_header.e_machine == EM_D30V
10135 || elf_header.e_machine == EM_CYGNUS_D30V)
10136 && reloc_type == 12))
91d6fa6a 10137 addend += byte_get (rloc, reloc_size);
cb8f3167 10138
85acf597
RH		 10139 if (is_32bit_pcrel_reloc (reloc_type)
10140 || is_64bit_pcrel_reloc (reloc_type))
10141 {
10142 /* On HPPA, all pc-relative relocations are biased by 8. */
10143 if (elf_header.e_machine == EM_PARISC)
10144 addend -= 8;
91d6fa6a 10145 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10146 reloc_size);
10147 }
41e92641 10148 else
91d6fa6a 10149 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10150 }
252b5132 10151
5b18a4bc 10152 free (symtab);
41e92641 10153 free (relocs);
5b18a4bc
NC		 10154 break;
10155 }
5b18a4bc 10156}
103f02d3 10157
cf13d699
NC		 10158#ifdef SUPPORT_DISASSEMBLY
10159static int
10160disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10161{
10162 printf (_("\nAssembly dump of section %s\n"),
10163 SECTION_NAME (section));
10164
10165 /* XXX -- to be done --- XXX */
10166
10167 return 1;
10168}
10169#endif
10170
10171/* Reads in the contents of SECTION from FILE, returning a pointer
10172 to a malloc'ed buffer or NULL if something went wrong. */
10173
10174static char *
10175get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10176{
10177 bfd_size_type num_bytes;
10178
10179 num_bytes = section->sh_size;
10180
10181 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10182 {
10183 printf (_("\nSection '%s' has no data to dump.\n"),
10184 SECTION_NAME (section));
10185 return NULL;
10186 }
10187
3f5e193b
NC		 10188 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10189 _("section contents"));
cf13d699
NC		 10190}
10191
dd24e3da 10192
cf13d699
NC		 10193static void
10194dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10195{
10196 Elf_Internal_Shdr * relsec;
10197 bfd_size_type num_bytes;
cf13d699
NC		 10198 char * data;
10199 char * end;
10200 char * start;
10201 char * name = SECTION_NAME (section);
10202 bfd_boolean some_strings_shown;
10203
10204 start = get_section_contents (section, file);
10205 if (start == NULL)
10206 return;
10207
10208 printf (_("\nString dump of section '%s':\n"), name);
10209
10210 /* If the section being dumped has relocations against it the user might
10211 be expecting these relocations to have been applied. Check for this
10212 case and issue a warning message in order to avoid confusion.
10213 FIXME: Maybe we ought to have an option that dumps a section with
10214 relocs applied ? */
10215 for (relsec = section_headers;
10216 relsec < section_headers + elf_header.e_shnum;
10217 ++relsec)
10218 {
10219 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10220 || relsec->sh_info >= elf_header.e_shnum
10221 || section_headers + relsec->sh_info != section
10222 || relsec->sh_size == 0
10223 || relsec->sh_link >= elf_header.e_shnum)
10224 continue;
10225
10226 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10227 break;
10228 }
10229
10230 num_bytes = section->sh_size;
cf13d699
NC		 10231 data = start;
10232 end = start + num_bytes;
10233 some_strings_shown = FALSE;
10234
10235 while (data < end)
10236 {
10237 while (!ISPRINT (* data))
10238 if (++ data >= end)
10239 break;
10240
10241 if (data < end)
10242 {
10243#ifndef __MSVCRT__
c975cc98
NC		 10244 /* PR 11128: Use two separate invocations in order to work
10245 around bugs in the Solaris 8 implementation of printf. */
10246 printf (" [%6tx] ", data - start);
10247 printf ("%s\n", data);
cf13d699
NC		 10248#else
10249 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10250#endif
10251 data += strlen (data);
10252 some_strings_shown = TRUE;
10253 }
10254 }
10255
10256 if (! some_strings_shown)
10257 printf (_(" No strings found in this section."));
10258
10259 free (start);
10260
10261 putchar ('\n');
10262}
10263
10264static void
10265dump_section_as_bytes (Elf_Internal_Shdr * section,
10266 FILE * file,
10267 bfd_boolean relocate)
10268{
10269 Elf_Internal_Shdr * relsec;
10270 bfd_size_type bytes;
10271 bfd_vma addr;
10272 unsigned char * data;
10273 unsigned char * start;
10274
10275 start = (unsigned char *) get_section_contents (section, file);
10276 if (start == NULL)
10277 return;
10278
10279 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10280
10281 if (relocate)
10282 {
10283 apply_relocations (file, section, start);
10284 }
10285 else
10286 {
10287 /* If the section being dumped has relocations against it the user might
10288 be expecting these relocations to have been applied. Check for this
10289 case and issue a warning message in order to avoid confusion.
10290 FIXME: Maybe we ought to have an option that dumps a section with
10291 relocs applied ? */
10292 for (relsec = section_headers;
10293 relsec < section_headers + elf_header.e_shnum;
10294 ++relsec)
10295 {
10296 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10297 || relsec->sh_info >= elf_header.e_shnum
10298 || section_headers + relsec->sh_info != section
10299 || relsec->sh_size == 0
10300 || relsec->sh_link >= elf_header.e_shnum)
10301 continue;
10302
10303 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10304 break;
10305 }
10306 }
10307
10308 addr = section->sh_addr;
10309 bytes = section->sh_size;
10310 data = start;
10311
10312 while (bytes)
10313 {
10314 int j;
10315 int k;
10316 int lbytes;
10317
10318 lbytes = (bytes > 16 ? 16 : bytes);
10319
10320 printf (" 0x%8.8lx ", (unsigned long) addr);
10321
10322 for (j = 0; j < 16; j++)
10323 {
10324 if (j < lbytes)
10325 printf ("%2.2x", data[j]);
10326 else
10327 printf (" ");
10328
10329 if ((j & 3) == 3)
10330 printf (" ");
10331 }
10332
10333 for (j = 0; j < lbytes; j++)
10334 {
10335 k = data[j];
10336 if (k >= ' ' && k < 0x7f)
10337 printf ("%c", k);
10338 else
10339 printf (".");
10340 }
10341
10342 putchar ('\n');
10343
10344 data += lbytes;
10345 addr += lbytes;
10346 bytes -= lbytes;
10347 }
10348
10349 free (start);
10350
10351 putchar ('\n');
10352}
10353
4a114e3e 10354/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10355
10356static int
d3dbc530
AM		 10357uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10358 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10359{
10360#ifndef HAVE_ZLIB_H
cf13d699
NC		 10361 return FALSE;
10362#else
10363 dwarf_size_type compressed_size = *size;
10364 unsigned char * compressed_buffer = *buffer;
10365 dwarf_size_type uncompressed_size;
10366 unsigned char * uncompressed_buffer;
10367 z_stream strm;
10368 int rc;
10369 dwarf_size_type header_size = 12;
10370
10371 /* Read the zlib header. In this case, it should be "ZLIB" followed
10372 by the uncompressed section size, 8 bytes in big-endian order. */
10373 if (compressed_size < header_size
10374 || ! streq ((char *) compressed_buffer, "ZLIB"))
10375 return 0;
10376
10377 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10378 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10379 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10380 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10381 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10382 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10383 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10384 uncompressed_size += compressed_buffer[11];
10385
10386 /* It is possible the section consists of several compressed
10387 buffers concatenated together, so we uncompress in a loop. */
10388 strm.zalloc = NULL;
10389 strm.zfree = NULL;
10390 strm.opaque = NULL;
10391 strm.avail_in = compressed_size - header_size;
10392 strm.next_in = (Bytef *) compressed_buffer + header_size;
10393 strm.avail_out = uncompressed_size;
3f5e193b 10394 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10395
10396 rc = inflateInit (& strm);
10397 while (strm.avail_in > 0)
10398 {
10399 if (rc != Z_OK)
10400 goto fail;
10401 strm.next_out = ((Bytef *) uncompressed_buffer
10402 + (uncompressed_size - strm.avail_out));
10403 rc = inflate (&strm, Z_FINISH);
10404 if (rc != Z_STREAM_END)
10405 goto fail;
10406 rc = inflateReset (& strm);
10407 }
10408 rc = inflateEnd (& strm);
10409 if (rc != Z_OK
10410 || strm.avail_out != 0)
10411 goto fail;
10412
10413 free (compressed_buffer);
10414 *buffer = uncompressed_buffer;
10415 *size = uncompressed_size;
10416 return 1;
10417
10418 fail:
10419 free (uncompressed_buffer);
4a114e3e
L		 10420 /* Indicate decompression failure. */
10421 *buffer = NULL;
cf13d699
NC		 10422 return 0;
10423#endif /* HAVE_ZLIB_H */
10424}
10425
d966045b
DJ		 10426static int
10427load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10428 Elf_Internal_Shdr * sec, void * file)
1007acb3 10429{
2cf0635d 10430 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10431 char buf [64];
1007acb3 10432
19e6b90e
L		 10433 /* If it is already loaded, do nothing. */
10434 if (section->start != NULL)
10435 return 1;
1007acb3 10436
19e6b90e
L		 10437 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10438 section->address = sec->sh_addr;
3f5e193b
NC		 10439 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10440 sec->sh_offset, 1,
10441 sec->sh_size, buf);
59245841
NC		 10442 if (section->start == NULL)
10443 section->size = 0;
10444 else
10445 {
10446 section->size = sec->sh_size;
10447 if (uncompress_section_contents (&section->start, &section->size))
10448 sec->sh_size = section->size;
10449 }
4a114e3e 10450
1b315056
CS		 10451 if (section->start == NULL)
10452 return 0;
10453
19e6b90e 10454 if (debug_displays [debug].relocate)
3f5e193b 10455 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10456
1b315056 10457 return 1;
1007acb3
L		 10458}
10459
d966045b 10460int
2cf0635d 10461load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10462{
2cf0635d
NC		 10463 struct dwarf_section * section = &debug_displays [debug].section;
10464 Elf_Internal_Shdr * sec;
d966045b
DJ		 10465
10466 /* Locate the debug section. */
10467 sec = find_section (section->uncompressed_name);
10468 if (sec != NULL)
10469 section->name = section->uncompressed_name;
10470 else
10471 {
10472 sec = find_section (section->compressed_name);
10473 if (sec != NULL)
10474 section->name = section->compressed_name;
10475 }
10476 if (sec == NULL)
10477 return 0;
10478
3f5e193b 10479 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10480}
10481
19e6b90e
L		 10482void
10483free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10484{
2cf0635d 10485 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10486
19e6b90e
L		 10487 if (section->start == NULL)
10488 return;
1007acb3 10489
19e6b90e
L		 10490 free ((char *) section->start);
10491 section->start = NULL;
10492 section->address = 0;
10493 section->size = 0;
1007acb3
L		 10494}
10495
1007acb3 10496static int
2cf0635d 10497display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10498{
2cf0635d 10499 char * name = SECTION_NAME (section);
19e6b90e
L		 10500 bfd_size_type length;
10501 int result = 1;
3f5e193b 10502 int i;
1007acb3 10503
19e6b90e
L		 10504 length = section->sh_size;
10505 if (length == 0)
1007acb3 10506 {
19e6b90e
L		 10507 printf (_("\nSection '%s' has no debugging data.\n"), name);
10508 return 0;
1007acb3 10509 }
5dff79d8
NC		 10510 if (section->sh_type == SHT_NOBITS)
10511 {
10512 /* There is no point in dumping the contents of a debugging section
10513 which has the NOBITS type - the bits in the file will be random.
10514 This can happen when a file containing a .eh_frame section is
10515 stripped with the --only-keep-debug command line option. */
10516 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10517 return 0;
10518 }
1007acb3 10519
0112cd26 10520 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10521 name = ".debug_info";
1007acb3 10522
19e6b90e
L		 10523 /* See if we know how to display the contents of this section. */
10524 for (i = 0; i < max; i++)
1b315056
CS		 10525 if (streq (debug_displays[i].section.uncompressed_name, name)
10526 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10527 {
2cf0635d 10528 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10529 int secondary = (section != find_section (name));
10530
10531 if (secondary)
3f5e193b 10532 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10533
2b6f5997 10534 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10535 sec->name = sec->uncompressed_name;
10536 else
10537 sec->name = sec->compressed_name;
3f5e193b
NC		 10538 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10539 section, file))
19e6b90e
L		 10540 {
10541 result &= debug_displays[i].display (sec, file);
1007acb3 10542
d966045b 10543 if (secondary || (i != info && i != abbrev))
3f5e193b 10544 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10545 }
1007acb3 10546
19e6b90e
L		 10547 break;
10548 }
1007acb3 10549
19e6b90e 10550 if (i == max)
1007acb3 10551 {
19e6b90e
L		 10552 printf (_("Unrecognized debug section: %s\n"), name);
10553 result = 0;
1007acb3
L		 10554 }
10555
19e6b90e 10556 return result;
5b18a4bc 10557}
103f02d3 10558
aef1f6d0
DJ		 10559/* Set DUMP_SECTS for all sections where dumps were requested
10560 based on section name. */
10561
10562static void
10563initialise_dumps_byname (void)
10564{
2cf0635d 10565 struct dump_list_entry * cur;
aef1f6d0
DJ		 10566
10567 for (cur = dump_sects_byname; cur; cur = cur->next)
10568 {
10569 unsigned int i;
10570 int any;
10571
10572 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10573 if (streq (SECTION_NAME (section_headers + i), cur->name))
10574 {
09c11c86 10575 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10576 any = 1;
10577 }
10578
10579 if (!any)
10580 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10581 cur->name);
10582 }
10583}
10584
5b18a4bc 10585static void
2cf0635d 10586process_section_contents (FILE * file)
5b18a4bc 10587{
2cf0635d 10588 Elf_Internal_Shdr * section;
19e6b90e 10589 unsigned int i;
103f02d3 10590
19e6b90e
L		 10591 if (! do_dump)
10592 return;
103f02d3 10593
aef1f6d0
DJ		 10594 initialise_dumps_byname ();
10595
19e6b90e
L		 10596 for (i = 0, section = section_headers;
10597 i < elf_header.e_shnum && i < num_dump_sects;
10598 i++, section++)
10599 {
10600#ifdef SUPPORT_DISASSEMBLY
10601 if (dump_sects[i] & DISASS_DUMP)
10602 disassemble_section (section, file);
10603#endif
10604 if (dump_sects[i] & HEX_DUMP)
cf13d699 10605 dump_section_as_bytes (section, file, FALSE);
103f02d3 10606
cf13d699
NC		 10607 if (dump_sects[i] & RELOC_DUMP)
10608 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10609
10610 if (dump_sects[i] & STRING_DUMP)
10611 dump_section_as_strings (section, file);
cf13d699
NC		 10612
10613 if (dump_sects[i] & DEBUG_DUMP)
10614 display_debug_section (section, file);
5b18a4bc 10615 }
103f02d3 10616
19e6b90e
L		 10617 /* Check to see if the user requested a
10618 dump of a section that does not exist. */
10619 while (i++ < num_dump_sects)
10620 if (dump_sects[i])
10621 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10622}
103f02d3 10623
5b18a4bc 10624static void
19e6b90e 10625process_mips_fpe_exception (int mask)
5b18a4bc 10626{
19e6b90e
L		 10627 if (mask)
10628 {
10629 int first = 1;
10630 if (mask & OEX_FPU_INEX)
10631 fputs ("INEX", stdout), first = 0;
10632 if (mask & OEX_FPU_UFLO)
10633 printf ("%sUFLO", first ? "" : "|"), first = 0;
10634 if (mask & OEX_FPU_OFLO)
10635 printf ("%sOFLO", first ? "" : "|"), first = 0;
10636 if (mask & OEX_FPU_DIV0)
10637 printf ("%sDIV0", first ? "" : "|"), first = 0;
10638 if (mask & OEX_FPU_INVAL)
10639 printf ("%sINVAL", first ? "" : "|");
10640 }
5b18a4bc 10641 else
19e6b90e 10642 fputs ("0", stdout);
5b18a4bc 10643}
103f02d3 10644
11c1ff18
PB		 10645/* ARM EABI attributes section. */
10646typedef struct
10647{
10648 int tag;
2cf0635d 10649 const char * name;
11c1ff18
PB		 10650 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10651 int type;
2cf0635d 10652 const char ** table;
11c1ff18
PB		 10653} arm_attr_public_tag;
10654
2cf0635d 10655static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10656 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10657 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10658static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10659static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10660 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10661static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10662 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10663static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10664static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10665 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10666static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10667 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10668 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10669static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10670 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10671static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10672 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10673static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10674 {"Absolute", "PC-relative", "None"};
2cf0635d 10675static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10676 {"None", "direct", "GOT-indirect"};
2cf0635d 10677static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10678 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10679static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10680static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10681 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10682static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10683static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10684static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10685 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10686static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10687 {"Unused", "small", "int", "forced to int"};
2cf0635d 10688static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10689 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10690static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10691 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10692static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10693 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10694static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10695 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10696 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10697static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10698 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10699 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10700static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10701static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10702 {"Not Allowed", "Allowed"};
2cf0635d 10703static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10704 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10705static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10706 {"Not Allowed", "Allowed"};
10707static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10708 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10709 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10710static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10711static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10712 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10713 "TrustZone and Virtualization Extensions"};
dd24e3da 10714static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10715 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10716
10717#define LOOKUP(id, name) \
10718 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10719static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10720{
10721 {4, "CPU_raw_name", 1, NULL},
10722 {5, "CPU_name", 1, NULL},
10723 LOOKUP(6, CPU_arch),
10724 {7, "CPU_arch_profile", 0, NULL},
10725 LOOKUP(8, ARM_ISA_use),
10726 LOOKUP(9, THUMB_ISA_use),
75375b3e 10727 LOOKUP(10, FP_arch),
11c1ff18 10728 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10729 LOOKUP(12, Advanced_SIMD_arch),
10730 LOOKUP(13, PCS_config),
11c1ff18
PB		 10731 LOOKUP(14, ABI_PCS_R9_use),
10732 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10733 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10734 LOOKUP(17, ABI_PCS_GOT_use),
10735 LOOKUP(18, ABI_PCS_wchar_t),
10736 LOOKUP(19, ABI_FP_rounding),
10737 LOOKUP(20, ABI_FP_denormal),
10738 LOOKUP(21, ABI_FP_exceptions),
10739 LOOKUP(22, ABI_FP_user_exceptions),
10740 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10741 {24, "ABI_align_needed", 0, NULL},
10742 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10743 LOOKUP(26, ABI_enum_size),
10744 LOOKUP(27, ABI_HardFP_use),
10745 LOOKUP(28, ABI_VFP_args),
10746 LOOKUP(29, ABI_WMMX_args),
10747 LOOKUP(30, ABI_optimization_goals),
10748 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10749 {32, "compatibility", 0, NULL},
f5f53991 10750 LOOKUP(34, CPU_unaligned_access),
75375b3e 10751 LOOKUP(36, FP_HP_extension),
8e79c3df 10752 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10753 LOOKUP(42, MPextension_use),
10754 LOOKUP(44, DIV_use),
f5f53991
AS		 10755 {64, "nodefaults", 0, NULL},
10756 {65, "also_compatible_with", 0, NULL},
10757 LOOKUP(66, T2EE_use),
10758 {67, "conformance", 1, NULL},
10759 LOOKUP(68, Virtualization_use),
cd21e546 10760 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10761};
10762#undef LOOKUP
10763
11c1ff18 10764static unsigned char *
2cf0635d 10765display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10766{
10767 int tag;
10768 unsigned int len;
10769 int val;
2cf0635d 10770 arm_attr_public_tag * attr;
11c1ff18
PB		 10771 unsigned i;
10772 int type;
10773
10774 tag = read_uleb128 (p, &len);
10775 p += len;
10776 attr = NULL;
2cf0635d 10777 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10778 {
10779 if (arm_attr_public_tags[i].tag == tag)
10780 {
10781 attr = &arm_attr_public_tags[i];
10782 break;
10783 }
10784 }
10785
10786 if (attr)
10787 {
10788 printf (" Tag_%s: ", attr->name);
10789 switch (attr->type)
10790 {
10791 case 0:
10792 switch (tag)
10793 {
10794 case 7: /* Tag_CPU_arch_profile. */
10795 val = read_uleb128 (p, &len);
10796 p += len;
10797 switch (val)
10798 {
2b692964
NC		 10799 case 0: printf (_("None\n")); break;
10800 case 'A': printf (_("Application\n")); break;
10801 case 'R': printf (_("Realtime\n")); break;
10802 case 'M': printf (_("Microcontroller\n")); break;
10803 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10804 default: printf ("??? (%d)\n", val); break;
10805 }
10806 break;
10807
75375b3e
MGD		 10808 case 24: /* Tag_align_needed. */
10809 val = read_uleb128 (p, &len);
10810 p += len;
10811 switch (val)
10812 {
2b692964
NC		 10813 case 0: printf (_("None\n")); break;
10814 case 1: printf (_("8-byte\n")); break;
10815 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10816 case 3: printf ("??? 3\n"); break;
10817 default:
10818 if (val <= 12)
dd24e3da 10819 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10820 1 << val);
10821 else
10822 printf ("??? (%d)\n", val);
10823 break;
10824 }
10825 break;
10826
10827 case 25: /* Tag_align_preserved. */
10828 val = read_uleb128 (p, &len);
10829 p += len;
10830 switch (val)
10831 {
2b692964
NC		 10832 case 0: printf (_("None\n")); break;
10833 case 1: printf (_("8-byte, except leaf SP\n")); break;
10834 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10835 case 3: printf ("??? 3\n"); break;
10836 default:
10837 if (val <= 12)
dd24e3da 10838 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10839 1 << val);
10840 else
10841 printf ("??? (%d)\n", val);
10842 break;
10843 }
10844 break;
10845
11c1ff18
PB		 10846 case 32: /* Tag_compatibility. */
10847 val = read_uleb128 (p, &len);
10848 p += len;
2b692964 10849 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10850 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10851 break;
10852
f5f53991
AS		 10853 case 64: /* Tag_nodefaults. */
10854 p++;
2b692964 10855 printf (_("True\n"));
f5f53991
AS		 10856 break;
10857
10858 case 65: /* Tag_also_compatible_with. */
10859 val = read_uleb128 (p, &len);
10860 p += len;
10861 if (val == 6 /* Tag_CPU_arch. */)
10862 {
10863 val = read_uleb128 (p, &len);
10864 p += len;
2cf0635d 10865 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10866 printf ("??? (%d)\n", val);
10867 else
10868 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10869 }
10870 else
10871 printf ("???\n");
10872 while (*(p++) != '\0' /* NUL terminator. */);
10873 break;
10874
11c1ff18 10875 default:
2cf0635d 10876 abort ();
11c1ff18
PB		 10877 }
10878 return p;
10879
10880 case 1:
10881 case 2:
10882 type = attr->type;
10883 break;
10884
10885 default:
10886 assert (attr->type & 0x80);
10887 val = read_uleb128 (p, &len);
10888 p += len;
10889 type = attr->type & 0x7f;
10890 if (val >= type)
10891 printf ("??? (%d)\n", val);
10892 else
10893 printf ("%s\n", attr->table[val]);
10894 return p;
10895 }
10896 }
10897 else
10898 {
10899 if (tag & 1)
10900 type = 1; /* String. */
10901 else
10902 type = 2; /* uleb128. */
10903 printf (" Tag_unknown_%d: ", tag);
10904 }
10905
10906 if (type == 1)
10907 {
10908 printf ("\"%s\"\n", p);
2cf0635d 10909 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10910 }
10911 else
10912 {
10913 val = read_uleb128 (p, &len);
10914 p += len;
10915 printf ("%d (0x%x)\n", val, val);
10916 }
10917
10918 return p;
10919}
10920
104d59d1 10921static unsigned char *
60bca95a
NC		 10922display_gnu_attribute (unsigned char * p,
10923 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10924{
10925 int tag;
10926 unsigned int len;
10927 int val;
10928 int type;
10929
10930 tag = read_uleb128 (p, &len);
10931 p += len;
10932
10933 /* Tag_compatibility is the only generic GNU attribute defined at
10934 present. */
10935 if (tag == 32)
10936 {
10937 val = read_uleb128 (p, &len);
10938 p += len;
2b692964 10939 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10940 p += strlen ((char *) p) + 1;
104d59d1
JM		 10941 return p;
10942 }
10943
10944 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10945 return display_proc_gnu_attribute (p, tag);
10946
10947 if (tag & 1)
10948 type = 1; /* String. */
10949 else
10950 type = 2; /* uleb128. */
10951 printf (" Tag_unknown_%d: ", tag);
10952
10953 if (type == 1)
10954 {
10955 printf ("\"%s\"\n", p);
60bca95a 10956 p += strlen ((char *) p) + 1;
104d59d1
JM		 10957 }
10958 else
10959 {
10960 val = read_uleb128 (p, &len);
10961 p += len;
10962 printf ("%d (0x%x)\n", val, val);
10963 }
10964
10965 return p;
10966}
10967
34c8bcba 10968static unsigned char *
2cf0635d 10969display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10970{
10971 int type;
10972 unsigned int len;
10973 int val;
10974
10975 if (tag == Tag_GNU_Power_ABI_FP)
10976 {
10977 val = read_uleb128 (p, &len);
10978 p += len;
10979 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 10980
34c8bcba
JM		 10981 switch (val)
10982 {
10983 case 0:
2b692964 10984 printf (_("Hard or soft float\n"));
34c8bcba
JM		 10985 break;
10986 case 1:
2b692964 10987 printf (_("Hard float\n"));
34c8bcba
JM		 10988 break;
10989 case 2:
2b692964 10990 printf (_("Soft float\n"));
34c8bcba 10991 break;
3c7b9897 10992 case 3:
2b692964 10993 printf (_("Single-precision hard float\n"));
3c7b9897 10994 break;
34c8bcba
JM		 10995 default:
10996 printf ("??? (%d)\n", val);
10997 break;
10998 }
10999 return p;
11000 }
11001
c6e65352
DJ		 11002 if (tag == Tag_GNU_Power_ABI_Vector)
11003 {
11004 val = read_uleb128 (p, &len);
11005 p += len;
11006 printf (" Tag_GNU_Power_ABI_Vector: ");
11007 switch (val)
11008 {
11009 case 0:
2b692964 11010 printf (_("Any\n"));
c6e65352
DJ		 11011 break;
11012 case 1:
2b692964 11013 printf (_("Generic\n"));
c6e65352
DJ		 11014 break;
11015 case 2:
11016 printf ("AltiVec\n");
11017 break;
11018 case 3:
11019 printf ("SPE\n");
11020 break;
11021 default:
11022 printf ("??? (%d)\n", val);
11023 break;
11024 }
11025 return p;
11026 }
11027
f82e0623
NF		 11028 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11029 {
11030 val = read_uleb128 (p, &len);
11031 p += len;
11032 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11033 switch (val)
11034 {
11035 case 0:
2b692964 11036 printf (_("Any\n"));
f82e0623
NF		 11037 break;
11038 case 1:
11039 printf ("r3/r4\n");
11040 break;
11041 case 2:
2b692964 11042 printf (_("Memory\n"));
f82e0623
NF		 11043 break;
11044 default:
11045 printf ("??? (%d)\n", val);
11046 break;
11047 }
11048 return p;
11049 }
11050
34c8bcba
JM		 11051 if (tag & 1)
11052 type = 1; /* String. */
11053 else
11054 type = 2; /* uleb128. */
11055 printf (" Tag_unknown_%d: ", tag);
11056
11057 if (type == 1)
11058 {
11059 printf ("\"%s\"\n", p);
60bca95a 11060 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11061 }
11062 else
11063 {
11064 val = read_uleb128 (p, &len);
11065 p += len;
11066 printf ("%d (0x%x)\n", val, val);
11067 }
11068
11069 return p;
11070}
11071
2cf19d5c 11072static unsigned char *
2cf0635d 11073display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11074{
11075 int type;
11076 unsigned int len;
11077 int val;
11078
11079 if (tag == Tag_GNU_MIPS_ABI_FP)
11080 {
11081 val = read_uleb128 (p, &len);
11082 p += len;
11083 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11084
2cf19d5c
JM		 11085 switch (val)
11086 {
11087 case 0:
2b692964 11088 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11089 break;
11090 case 1:
2b692964 11091 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11092 break;
11093 case 2:
2b692964 11094 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11095 break;
11096 case 3:
2b692964 11097 printf (_("Soft float\n"));
2cf19d5c 11098 break;
42554f6a 11099 case 4:
9eeefea8 11100 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11101 break;
2cf19d5c
JM		 11102 default:
11103 printf ("??? (%d)\n", val);
11104 break;
11105 }
11106 return p;
11107 }
11108
11109 if (tag & 1)
11110 type = 1; /* String. */
11111 else
11112 type = 2; /* uleb128. */
11113 printf (" Tag_unknown_%d: ", tag);
11114
11115 if (type == 1)
11116 {
11117 printf ("\"%s\"\n", p);
60bca95a 11118 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11119 }
11120 else
11121 {
11122 val = read_uleb128 (p, &len);
11123 p += len;
11124 printf ("%d (0x%x)\n", val, val);
11125 }
11126
11127 return p;
11128}
11129
59e6276b
JM		 11130static unsigned char *
11131display_tic6x_attribute (unsigned char * p)
11132{
11133 int tag;
11134 unsigned int len;
11135 int val;
11136
11137 tag = read_uleb128 (p, &len);
11138 p += len;
11139
11140 switch (tag)
11141 {
75fa6dc1 11142 case Tag_ISA:
59e6276b
JM		 11143 val = read_uleb128 (p, &len);
11144 p += len;
75fa6dc1 11145 printf (" Tag_ISA: ");
59e6276b
JM		 11146
11147 switch (val)
11148 {
75fa6dc1 11149 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11150 printf (_("None\n"));
11151 break;
75fa6dc1 11152 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11153 printf ("C62x\n");
11154 break;
75fa6dc1 11155 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11156 printf ("C67x\n");
11157 break;
75fa6dc1 11158 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11159 printf ("C67x+\n");
11160 break;
75fa6dc1 11161 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11162 printf ("C64x\n");
11163 break;
75fa6dc1 11164 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11165 printf ("C64x+\n");
11166 break;
75fa6dc1 11167 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11168 printf ("C674x\n");
11169 break;
11170 default:
11171 printf ("??? (%d)\n", val);
11172 break;
11173 }
11174 return p;
11175
87779176
JM		 11176 case Tag_ABI_wchar_t:
11177 val = read_uleb128 (p, &len);
11178 p += len;
11179 printf (" Tag_ABI_wchar_t: ");
11180 switch (val)
11181 {
11182 case 0:
11183 printf (_("Not used\n"));
11184 break;
11185 case 1:
11186 printf (_("2 bytes\n"));
11187 break;
11188 case 2:
11189 printf (_("4 bytes\n"));
11190 break;
11191 default:
11192 printf ("??? (%d)\n", val);
11193 break;
11194 }
11195 return p;
11196
11197 case Tag_ABI_stack_align_needed:
11198 val = read_uleb128 (p, &len);
11199 p += len;
11200 printf (" Tag_ABI_stack_align_needed: ");
11201 switch (val)
11202 {
11203 case 0:
11204 printf (_("8-byte\n"));
11205 break;
11206 case 1:
11207 printf (_("16-byte\n"));
11208 break;
11209 default:
11210 printf ("??? (%d)\n", val);
11211 break;
11212 }
11213 return p;
11214
11215 case Tag_ABI_stack_align_preserved:
11216 val = read_uleb128 (p, &len);
11217 p += len;
11218 printf (" Tag_ABI_stack_align_preserved: ");
11219 switch (val)
11220 {
11221 case 0:
11222 printf (_("8-byte\n"));
11223 break;
11224 case 1:
11225 printf (_("16-byte\n"));
11226 break;
11227 default:
11228 printf ("??? (%d)\n", val);
11229 break;
11230 }
11231 return p;
11232
b5593623
JM		 11233 case Tag_ABI_DSBT:
11234 val = read_uleb128 (p, &len);
11235 p += len;
11236 printf (" Tag_ABI_DSBT: ");
11237 switch (val)
11238 {
11239 case 0:
11240 printf (_("DSBT addressing not used\n"));
11241 break;
11242 case 1:
11243 printf (_("DSBT addressing used\n"));
11244 break;
11245 default:
11246 printf ("??? (%d)\n", val);
11247 break;
11248 }
11249 return p;
11250
87779176
JM		 11251 case Tag_ABI_PID:
11252 val = read_uleb128 (p, &len);
11253 p += len;
11254 printf (" Tag_ABI_PID: ");
11255 switch (val)
11256 {
11257 case 0:
11258 printf (_("Data addressing position-dependent\n"));
11259 break;
11260 case 1:
11261 printf (_("Data addressing position-independent, GOT near DP\n"));
11262 break;
11263 case 2:
11264 printf (_("Data addressing position-independent, GOT far from DP\n"));
11265 break;
11266 default:
11267 printf ("??? (%d)\n", val);
11268 break;
11269 }
11270 return p;
11271
11272 case Tag_ABI_PIC:
11273 val = read_uleb128 (p, &len);
11274 p += len;
11275 printf (" Tag_ABI_PIC: ");
11276 switch (val)
11277 {
11278 case 0:
11279 printf (_("Code addressing position-dependent\n"));
11280 break;
11281 case 1:
11282 printf (_("Code addressing position-independent\n"));
11283 break;
11284 default:
11285 printf ("??? (%d)\n", val);
11286 break;
11287 }
11288 return p;
11289
11290 case Tag_ABI_array_object_alignment:
11291 val = read_uleb128 (p, &len);
11292 p += len;
11293 printf (" Tag_ABI_array_object_alignment: ");
11294 switch (val)
11295 {
11296 case 0:
11297 printf (_("8-byte\n"));
11298 break;
11299 case 1:
11300 printf (_("4-byte\n"));
11301 break;
11302 case 2:
11303 printf (_("16-byte\n"));
11304 break;
11305 default:
11306 printf ("??? (%d)\n", val);
11307 break;
11308 }
11309 return p;
11310
11311 case Tag_ABI_array_object_align_expected:
11312 val = read_uleb128 (p, &len);
11313 p += len;
11314 printf (" Tag_ABI_array_object_align_expected: ");
11315 switch (val)
11316 {
11317 case 0:
11318 printf (_("8-byte\n"));
11319 break;
11320 case 1:
11321 printf (_("4-byte\n"));
11322 break;
11323 case 2:
11324 printf (_("16-byte\n"));
11325 break;
11326 default:
11327 printf ("??? (%d)\n", val);
11328 break;
11329 }
11330 return p;
11331
3cbd1c06 11332 case Tag_ABI_compatibility:
59e6276b
JM		 11333 val = read_uleb128 (p, &len);
11334 p += len;
3cbd1c06 11335 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11336 printf (_("flag = %d, vendor = %s\n"), val, p);
11337 p += strlen ((char *) p) + 1;
11338 return p;
87779176
JM		 11339
11340 case Tag_ABI_conformance:
11341 printf (" Tag_ABI_conformance: ");
11342 printf ("\"%s\"\n", p);
11343 p += strlen ((char *) p) + 1;
11344 return p;
59e6276b
JM		 11345 }
11346
11347 printf (" Tag_unknown_%d: ", tag);
11348
87779176
JM		 11349 if (tag & 1)
11350 {
11351 printf ("\"%s\"\n", p);
11352 p += strlen ((char *) p) + 1;
11353 }
11354 else
11355 {
11356 val = read_uleb128 (p, &len);
11357 p += len;
11358 printf ("%d (0x%x)\n", val, val);
11359 }
59e6276b
JM		 11360
11361 return p;
11362}
11363
11c1ff18 11364static int
60bca95a
NC		 11365process_attributes (FILE * file,
11366 const char * public_name,
104d59d1 11367 unsigned int proc_type,
60bca95a
NC		 11368 unsigned char * (* display_pub_attribute) (unsigned char *),
11369 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11370{
2cf0635d
NC		 11371 Elf_Internal_Shdr * sect;
11372 unsigned char * contents;
11373 unsigned char * p;
11374 unsigned char * end;
11c1ff18
PB		 11375 bfd_vma section_len;
11376 bfd_vma len;
11377 unsigned i;
11378
11379 /* Find the section header so that we get the size. */
11380 for (i = 0, sect = section_headers;
11381 i < elf_header.e_shnum;
11382 i++, sect++)
11383 {
104d59d1 11384 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11385 continue;
11386
3f5e193b
NC		 11387 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11388 sect->sh_size, _("attributes"));
60bca95a 11389 if (contents == NULL)
11c1ff18 11390 continue;
60bca95a 11391
11c1ff18
PB		 11392 p = contents;
11393 if (*p == 'A')
11394 {
11395 len = sect->sh_size - 1;
11396 p++;
60bca95a 11397
11c1ff18
PB		 11398 while (len > 0)
11399 {
11400 int namelen;
11401 bfd_boolean public_section;
104d59d1 11402 bfd_boolean gnu_section;
11c1ff18
PB		 11403
11404 section_len = byte_get (p, 4);
11405 p += 4;
60bca95a 11406
11c1ff18
PB		 11407 if (section_len > len)
11408 {
11409 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11410 (int) section_len, (int) len);
11c1ff18
PB		 11411 section_len = len;
11412 }
60bca95a 11413
11c1ff18 11414 len -= section_len;
2b692964 11415 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11416
11417 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11418 public_section = TRUE;
11419 else
11420 public_section = FALSE;
60bca95a
NC		 11421
11422 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11423 gnu_section = TRUE;
11424 else
11425 gnu_section = FALSE;
60bca95a
NC		 11426
11427 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11428 p += namelen;
11429 section_len -= namelen + 4;
60bca95a 11430
11c1ff18
PB		 11431 while (section_len > 0)
11432 {
11433 int tag = *(p++);
11434 int val;
11435 bfd_vma size;
60bca95a 11436
11c1ff18
PB		 11437 size = byte_get (p, 4);
11438 if (size > section_len)
11439 {
11440 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11441 (int) size, (int) section_len);
11c1ff18
PB		 11442 size = section_len;
11443 }
60bca95a 11444
11c1ff18
PB		 11445 section_len -= size;
11446 end = p + size - 1;
11447 p += 4;
60bca95a 11448
11c1ff18
PB		 11449 switch (tag)
11450 {
11451 case 1:
2b692964 11452 printf (_("File Attributes\n"));
11c1ff18
PB		 11453 break;
11454 case 2:
2b692964 11455 printf (_("Section Attributes:"));
11c1ff18
PB		 11456 goto do_numlist;
11457 case 3:
2b692964 11458 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11459 do_numlist:
11460 for (;;)
11461 {
91d6fa6a 11462 unsigned int j;
60bca95a 11463
91d6fa6a
NC		 11464 val = read_uleb128 (p, &j);
11465 p += j;
11c1ff18
PB		 11466 if (val == 0)
11467 break;
11468 printf (" %d", val);
11469 }
11470 printf ("\n");
11471 break;
11472 default:
2b692964 11473 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11474 public_section = FALSE;
11475 break;
11476 }
60bca95a 11477
11c1ff18
PB		 11478 if (public_section)
11479 {
11480 while (p < end)
104d59d1
JM		 11481 p = display_pub_attribute (p);
11482 }
11483 else if (gnu_section)
11484 {
11485 while (p < end)
11486 p = display_gnu_attribute (p,
11487 display_proc_gnu_attribute);
11c1ff18
PB		 11488 }
11489 else
11490 {
11491 /* ??? Do something sensible, like dump hex. */
2b692964 11492 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11493 p = end;
11494 }
11495 }
11496 }
11497 }
11498 else
60bca95a 11499 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11500
60bca95a 11501 free (contents);
11c1ff18
PB		 11502 }
11503 return 1;
11504}
11505
104d59d1 11506static int
2cf0635d 11507process_arm_specific (FILE * file)
104d59d1
JM		 11508{
11509 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11510 display_arm_attribute, NULL);
11511}
11512
34c8bcba 11513static int
2cf0635d 11514process_power_specific (FILE * file)
34c8bcba
JM		 11515{
11516 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11517 display_power_gnu_attribute);
11518}
11519
59e6276b
JM		 11520static int
11521process_tic6x_specific (FILE * file)
11522{
11523 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11524 display_tic6x_attribute, NULL);
11525}
11526
ccb4c951
RS		 11527/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11528 Print the Address, Access and Initial fields of an entry at VMA ADDR
11529 and return the VMA of the next entry. */
11530
11531static bfd_vma
2cf0635d 11532print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11533{
11534 printf (" ");
11535 print_vma (addr, LONG_HEX);
11536 printf (" ");
11537 if (addr < pltgot + 0xfff0)
11538 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11539 else
11540 printf ("%10s", "");
11541 printf (" ");
11542 if (data == NULL)
2b692964 11543 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11544 else
11545 {
11546 bfd_vma entry;
11547
11548 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11549 print_vma (entry, LONG_HEX);
11550 }
11551 return addr + (is_32bit_elf ? 4 : 8);
11552}
11553
861fb55a
DJ		 11554/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11555 PLTGOT. Print the Address and Initial fields of an entry at VMA
11556 ADDR and return the VMA of the next entry. */
11557
11558static bfd_vma
2cf0635d 11559print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11560{
11561 printf (" ");
11562 print_vma (addr, LONG_HEX);
11563 printf (" ");
11564 if (data == NULL)
2b692964 11565 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11566 else
11567 {
11568 bfd_vma entry;
11569
11570 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11571 print_vma (entry, LONG_HEX);
11572 }
11573 return addr + (is_32bit_elf ? 4 : 8);
11574}
11575
19e6b90e 11576static int
2cf0635d 11577process_mips_specific (FILE * file)
5b18a4bc 11578{
2cf0635d 11579 Elf_Internal_Dyn * entry;
19e6b90e
L		 11580 size_t liblist_offset = 0;
11581 size_t liblistno = 0;
11582 size_t conflictsno = 0;
11583 size_t options_offset = 0;
11584 size_t conflicts_offset = 0;
861fb55a
DJ		 11585 size_t pltrelsz = 0;
11586 size_t pltrel = 0;
ccb4c951 11587 bfd_vma pltgot = 0;
861fb55a
DJ		 11588 bfd_vma mips_pltgot = 0;
11589 bfd_vma jmprel = 0;
ccb4c951
RS		 11590 bfd_vma local_gotno = 0;
11591 bfd_vma gotsym = 0;
11592 bfd_vma symtabno = 0;
103f02d3 11593
2cf19d5c
JM		 11594 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11595 display_mips_gnu_attribute);
11596
19e6b90e
L		 11597 /* We have a lot of special sections. Thanks SGI! */
11598 if (dynamic_section == NULL)
11599 /* No information available. */
11600 return 0;
252b5132 11601
b2d38a17 11602 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11603 switch (entry->d_tag)
11604 {
11605 case DT_MIPS_LIBLIST:
d93f0186
NC		 11606 liblist_offset
11607 = offset_from_vma (file, entry->d_un.d_val,
11608 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11609 break;
11610 case DT_MIPS_LIBLISTNO:
11611 liblistno = entry->d_un.d_val;
11612 break;
11613 case DT_MIPS_OPTIONS:
d93f0186 11614 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11615 break;
11616 case DT_MIPS_CONFLICT:
d93f0186
NC		 11617 conflicts_offset
11618 = offset_from_vma (file, entry->d_un.d_val,
11619 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11620 break;
11621 case DT_MIPS_CONFLICTNO:
11622 conflictsno = entry->d_un.d_val;
11623 break;
ccb4c951 11624 case DT_PLTGOT:
861fb55a
DJ		 11625 pltgot = entry->d_un.d_ptr;
11626 break;
ccb4c951
RS		 11627 case DT_MIPS_LOCAL_GOTNO:
11628 local_gotno = entry->d_un.d_val;
11629 break;
11630 case DT_MIPS_GOTSYM:
11631 gotsym = entry->d_un.d_val;
11632 break;
11633 case DT_MIPS_SYMTABNO:
11634 symtabno = entry->d_un.d_val;
11635 break;
861fb55a
DJ		 11636 case DT_MIPS_PLTGOT:
11637 mips_pltgot = entry->d_un.d_ptr;
11638 break;
11639 case DT_PLTREL:
11640 pltrel = entry->d_un.d_val;
11641 break;
11642 case DT_PLTRELSZ:
11643 pltrelsz = entry->d_un.d_val;
11644 break;
11645 case DT_JMPREL:
11646 jmprel = entry->d_un.d_ptr;
11647 break;
252b5132
RH		 11648 default:
11649 break;
11650 }
11651
11652 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11653 {
2cf0635d 11654 Elf32_External_Lib * elib;
252b5132
RH		 11655 size_t cnt;
11656
3f5e193b
NC		 11657 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11658 liblistno,
11659 sizeof (Elf32_External_Lib),
11660 _("liblist"));
a6e9f9df 11661 if (elib)
252b5132 11662 {
2b692964 11663 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11664 (unsigned long) liblistno);
2b692964 11665 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11666 stdout);
11667
11668 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11669 {
a6e9f9df 11670 Elf32_Lib liblist;
91d6fa6a 11671 time_t atime;
a6e9f9df 11672 char timebuf[20];
2cf0635d 11673 struct tm * tmp;
a6e9f9df
AM		 11674
11675 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11676 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11677 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11678 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11679 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11680
91d6fa6a 11681 tmp = gmtime (&atime);
e9e44622
JJ		 11682 snprintf (timebuf, sizeof (timebuf),
11683 "%04u-%02u-%02uT%02u:%02u:%02u",
11684 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11685 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11686
31104126 11687 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11688 if (VALID_DYNAMIC_NAME (liblist.l_name))
11689 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11690 else
2b692964 11691 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11692 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11693 liblist.l_version);
a6e9f9df
AM		 11694
11695 if (liblist.l_flags == 0)
2b692964 11696 puts (_(" NONE"));
a6e9f9df
AM		 11697 else
11698 {
11699 static const struct
252b5132 11700 {
2cf0635d 11701 const char * name;
a6e9f9df 11702 int bit;
252b5132 11703 }
a6e9f9df
AM		 11704 l_flags_vals[] =
11705 {
11706 { " EXACT_MATCH", LL_EXACT_MATCH },
11707 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11708 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11709 { " EXPORTS", LL_EXPORTS },
11710 { " DELAY_LOAD", LL_DELAY_LOAD },
11711 { " DELTA", LL_DELTA }
11712 };
11713 int flags = liblist.l_flags;
11714 size_t fcnt;
11715
60bca95a 11716 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11717 if ((flags & l_flags_vals[fcnt].bit) != 0)
11718 {
11719 fputs (l_flags_vals[fcnt].name, stdout);
11720 flags ^= l_flags_vals[fcnt].bit;
11721 }
11722 if (flags != 0)
11723 printf (" %#x", (unsigned int) flags);
252b5132 11724
a6e9f9df
AM		 11725 puts ("");
11726 }
252b5132 11727 }
252b5132 11728
a6e9f9df
AM		 11729 free (elib);
11730 }
252b5132
RH		 11731 }
11732
11733 if (options_offset != 0)
11734 {
2cf0635d
NC		 11735 Elf_External_Options * eopt;
11736 Elf_Internal_Shdr * sect = section_headers;
11737 Elf_Internal_Options * iopt;
11738 Elf_Internal_Options * option;
252b5132
RH		 11739 size_t offset;
11740 int cnt;
11741
11742 /* Find the section header so that we get the size. */
11743 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11744 ++sect;
252b5132 11745
3f5e193b
NC		 11746 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11747 sect->sh_size, _("options"));
a6e9f9df 11748 if (eopt)
252b5132 11749 {
3f5e193b
NC		 11750 iopt = (Elf_Internal_Options *)
11751 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11752 if (iopt == NULL)
11753 {
591a748a 11754 error (_("Out of memory\n"));
a6e9f9df
AM		 11755 return 0;
11756 }
76da6bbe 11757
a6e9f9df
AM		 11758 offset = cnt = 0;
11759 option = iopt;
252b5132 11760
a6e9f9df
AM		 11761 while (offset < sect->sh_size)
11762 {
2cf0635d 11763 Elf_External_Options * eoption;
252b5132 11764
a6e9f9df 11765 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11766
a6e9f9df
AM		 11767 option->kind = BYTE_GET (eoption->kind);
11768 option->size = BYTE_GET (eoption->size);
11769 option->section = BYTE_GET (eoption->section);
11770 option->info = BYTE_GET (eoption->info);
76da6bbe 11771
a6e9f9df 11772 offset += option->size;
252b5132 11773
a6e9f9df
AM		 11774 ++option;
11775 ++cnt;
11776 }
252b5132 11777
a6e9f9df
AM		 11778 printf (_("\nSection '%s' contains %d entries:\n"),
11779 SECTION_NAME (sect), cnt);
76da6bbe 11780
a6e9f9df 11781 option = iopt;
252b5132 11782
a6e9f9df 11783 while (cnt-- > 0)
252b5132 11784 {
a6e9f9df
AM		 11785 size_t len;
11786
11787 switch (option->kind)
252b5132 11788 {
a6e9f9df
AM		 11789 case ODK_NULL:
11790 /* This shouldn't happen. */
11791 printf (" NULL %d %lx", option->section, option->info);
11792 break;
11793 case ODK_REGINFO:
11794 printf (" REGINFO ");
11795 if (elf_header.e_machine == EM_MIPS)
11796 {
11797 /* 32bit form. */
2cf0635d 11798 Elf32_External_RegInfo * ereg;
b34976b6 11799 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11800
11801 ereg = (Elf32_External_RegInfo *) (option + 1);
11802 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11803 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11804 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11805 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11806 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11807 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11808
11809 printf ("GPR %08lx GP 0x%lx\n",
11810 reginfo.ri_gprmask,
11811 (unsigned long) reginfo.ri_gp_value);
11812 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11813 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11814 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11815 }
11816 else
11817 {
11818 /* 64 bit form. */
2cf0635d 11819 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11820 Elf64_Internal_RegInfo reginfo;
11821
11822 ereg = (Elf64_External_RegInfo *) (option + 1);
11823 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11824 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11825 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11826 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11827 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11828 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11829
11830 printf ("GPR %08lx GP 0x",
11831 reginfo.ri_gprmask);
11832 printf_vma (reginfo.ri_gp_value);
11833 printf ("\n");
11834
11835 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11836 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11837 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11838 }
11839 ++option;
11840 continue;
11841 case ODK_EXCEPTIONS:
11842 fputs (" EXCEPTIONS fpe_min(", stdout);
11843 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11844 fputs (") fpe_max(", stdout);
11845 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11846 fputs (")", stdout);
11847
11848 if (option->info & OEX_PAGE0)
11849 fputs (" PAGE0", stdout);
11850 if (option->info & OEX_SMM)
11851 fputs (" SMM", stdout);
11852 if (option->info & OEX_FPDBUG)
11853 fputs (" FPDBUG", stdout);
11854 if (option->info & OEX_DISMISS)
11855 fputs (" DISMISS", stdout);
11856 break;
11857 case ODK_PAD:
11858 fputs (" PAD ", stdout);
11859 if (option->info & OPAD_PREFIX)
11860 fputs (" PREFIX", stdout);
11861 if (option->info & OPAD_POSTFIX)
11862 fputs (" POSTFIX", stdout);
11863 if (option->info & OPAD_SYMBOL)
11864 fputs (" SYMBOL", stdout);
11865 break;
11866 case ODK_HWPATCH:
11867 fputs (" HWPATCH ", stdout);
11868 if (option->info & OHW_R4KEOP)
11869 fputs (" R4KEOP", stdout);
11870 if (option->info & OHW_R8KPFETCH)
11871 fputs (" R8KPFETCH", stdout);
11872 if (option->info & OHW_R5KEOP)
11873 fputs (" R5KEOP", stdout);
11874 if (option->info & OHW_R5KCVTL)
11875 fputs (" R5KCVTL", stdout);
11876 break;
11877 case ODK_FILL:
11878 fputs (" FILL ", stdout);
11879 /* XXX Print content of info word? */
11880 break;
11881 case ODK_TAGS:
11882 fputs (" TAGS ", stdout);
11883 /* XXX Print content of info word? */
11884 break;
11885 case ODK_HWAND:
11886 fputs (" HWAND ", stdout);
11887 if (option->info & OHWA0_R4KEOP_CHECKED)
11888 fputs (" R4KEOP_CHECKED", stdout);
11889 if (option->info & OHWA0_R4KEOP_CLEAN)
11890 fputs (" R4KEOP_CLEAN", stdout);
11891 break;
11892 case ODK_HWOR:
11893 fputs (" HWOR ", stdout);
11894 if (option->info & OHWA0_R4KEOP_CHECKED)
11895 fputs (" R4KEOP_CHECKED", stdout);
11896 if (option->info & OHWA0_R4KEOP_CLEAN)
11897 fputs (" R4KEOP_CLEAN", stdout);
11898 break;
11899 case ODK_GP_GROUP:
11900 printf (" GP_GROUP %#06lx self-contained %#06lx",
11901 option->info & OGP_GROUP,
11902 (option->info & OGP_SELF) >> 16);
11903 break;
11904 case ODK_IDENT:
11905 printf (" IDENT %#06lx self-contained %#06lx",
11906 option->info & OGP_GROUP,
11907 (option->info & OGP_SELF) >> 16);
11908 break;
11909 default:
11910 /* This shouldn't happen. */
11911 printf (" %3d ??? %d %lx",
11912 option->kind, option->section, option->info);
11913 break;
252b5132 11914 }
a6e9f9df 11915
2cf0635d 11916 len = sizeof (* eopt);
a6e9f9df
AM		 11917 while (len < option->size)
11918 if (((char *) option)[len] >= ' '
11919 && ((char *) option)[len] < 0x7f)
11920 printf ("%c", ((char *) option)[len++]);
11921 else
11922 printf ("\\%03o", ((char *) option)[len++]);
11923
11924 fputs ("\n", stdout);
252b5132 11925 ++option;
252b5132
RH		 11926 }
11927
a6e9f9df 11928 free (eopt);
252b5132 11929 }
252b5132
RH		 11930 }
11931
11932 if (conflicts_offset != 0 && conflictsno != 0)
11933 {
2cf0635d 11934 Elf32_Conflict * iconf;
252b5132
RH		 11935 size_t cnt;
11936
11937 if (dynamic_symbols == NULL)
11938 {
591a748a 11939 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 11940 return 0;
11941 }
11942
3f5e193b 11943 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 11944 if (iconf == NULL)
11945 {
591a748a 11946 error (_("Out of memory\n"));
252b5132
RH		 11947 return 0;
11948 }
11949
9ea033b2 11950 if (is_32bit_elf)
252b5132 11951 {
2cf0635d 11952 Elf32_External_Conflict * econf32;
a6e9f9df 11953
3f5e193b
NC		 11954 econf32 = (Elf32_External_Conflict *)
11955 get_data (NULL, file, conflicts_offset, conflictsno,
11956 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 11957 if (!econf32)
11958 return 0;
252b5132
RH		 11959
11960 for (cnt = 0; cnt < conflictsno; ++cnt)
11961 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 11962
11963 free (econf32);
252b5132
RH		 11964 }
11965 else
11966 {
2cf0635d 11967 Elf64_External_Conflict * econf64;
a6e9f9df 11968
3f5e193b
NC		 11969 econf64 = (Elf64_External_Conflict *)
11970 get_data (NULL, file, conflicts_offset, conflictsno,
11971 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 11972 if (!econf64)
11973 return 0;
252b5132
RH		 11974
11975 for (cnt = 0; cnt < conflictsno; ++cnt)
11976 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 11977
11978 free (econf64);
252b5132
RH		 11979 }
11980
c7e7ca54
NC		 11981 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11982 (unsigned long) conflictsno);
252b5132
RH		 11983 puts (_(" Num: Index Value Name"));
11984
11985 for (cnt = 0; cnt < conflictsno; ++cnt)
11986 {
2cf0635d 11987 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 11988
b34976b6 11989 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 11990 print_vma (psym->st_value, FULL_HEX);
31104126 11991 putchar (' ');
d79b3d50
NC		 11992 if (VALID_DYNAMIC_NAME (psym->st_name))
11993 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11994 else
2b692964 11995 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 11996 putchar ('\n');
252b5132
RH		 11997 }
11998
252b5132
RH		 11999 free (iconf);
12000 }
12001
ccb4c951
RS		 12002 if (pltgot != 0 && local_gotno != 0)
12003 {
91d6fa6a 12004 bfd_vma ent, local_end, global_end;
bbeee7ea 12005 size_t i, offset;
2cf0635d 12006 unsigned char * data;
bbeee7ea 12007 int addr_size;
ccb4c951 12008
91d6fa6a 12009 ent = pltgot;
ccb4c951
RS		 12010 addr_size = (is_32bit_elf ? 4 : 8);
12011 local_end = pltgot + local_gotno * addr_size;
12012 global_end = local_end + (symtabno - gotsym) * addr_size;
12013
12014 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 12015 data = (unsigned char *) get_data (NULL, file, offset,
12016 global_end - pltgot, 1, _("GOT"));
59245841
NC		 12017 if (data == NULL)
12018 return 0;
12019
ccb4c951
RS		 12020 printf (_("\nPrimary GOT:\n"));
12021 printf (_(" Canonical gp value: "));
12022 print_vma (pltgot + 0x7ff0, LONG_HEX);
12023 printf ("\n\n");
12024
12025 printf (_(" Reserved entries:\n"));
12026 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12027 addr_size * 2, _("Address"), _("Access"),
12028 addr_size * 2, _("Initial"));
91d6fa6a 12029 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12030 printf (_(" Lazy resolver\n"));
ccb4c951 12031 if (data
91d6fa6a 12032 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12033 >> (addr_size * 8 - 1)) != 0)
12034 {
91d6fa6a 12035 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12036 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12037 }
12038 printf ("\n");
12039
91d6fa6a 12040 if (ent < local_end)
ccb4c951
RS		 12041 {
12042 printf (_(" Local entries:\n"));
cc5914eb 12043 printf (" %*s %10s %*s\n",
2b692964
NC		 12044 addr_size * 2, _("Address"), _("Access"),
12045 addr_size * 2, _("Initial"));
91d6fa6a 12046 while (ent < local_end)
ccb4c951 12047 {
91d6fa6a 12048 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12049 printf ("\n");
12050 }
12051 printf ("\n");
12052 }
12053
12054 if (gotsym < symtabno)
12055 {
12056 int sym_width;
12057
12058 printf (_(" Global entries:\n"));
cc5914eb 12059 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12060 addr_size * 2, _("Address"), _("Access"),
12061 addr_size * 2, _("Initial"),
12062 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 12063 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12064 for (i = gotsym; i < symtabno; i++)
12065 {
2cf0635d 12066 Elf_Internal_Sym * psym;
ccb4c951
RS		 12067
12068 psym = dynamic_symbols + i;
91d6fa6a 12069 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12070 printf (" ");
12071 print_vma (psym->st_value, LONG_HEX);
12072 printf (" %-7s %3s ",
12073 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12074 get_symbol_index_type (psym->st_shndx));
12075 if (VALID_DYNAMIC_NAME (psym->st_name))
12076 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12077 else
2b692964 12078 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12079 printf ("\n");
12080 }
12081 printf ("\n");
12082 }
12083
12084 if (data)
12085 free (data);
12086 }
12087
861fb55a
DJ		 12088 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12089 {
91d6fa6a 12090 bfd_vma ent, end;
861fb55a
DJ		 12091 size_t offset, rel_offset;
12092 unsigned long count, i;
2cf0635d 12093 unsigned char * data;
861fb55a 12094 int addr_size, sym_width;
2cf0635d 12095 Elf_Internal_Rela * rels;
861fb55a
DJ		 12096
12097 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12098 if (pltrel == DT_RELA)
12099 {
12100 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12101 return 0;
12102 }
12103 else
12104 {
12105 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12106 return 0;
12107 }
12108
91d6fa6a 12109 ent = mips_pltgot;
861fb55a
DJ		 12110 addr_size = (is_32bit_elf ? 4 : 8);
12111 end = mips_pltgot + (2 + count) * addr_size;
12112
12113 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 12114 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12115 1, _("PLT GOT"));
59245841
NC		 12116 if (data == NULL)
12117 return 0;
12118
861fb55a
DJ		 12119 printf (_("\nPLT GOT:\n\n"));
12120 printf (_(" Reserved entries:\n"));
12121 printf (_(" %*s %*s Purpose\n"),
2b692964 12122 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12123 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12124 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12125 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12126 printf (_(" Module pointer\n"));
861fb55a
DJ		 12127 printf ("\n");
12128
12129 printf (_(" Entries:\n"));
cc5914eb 12130 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12131 addr_size * 2, _("Address"),
12132 addr_size * 2, _("Initial"),
12133 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12134 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12135 for (i = 0; i < count; i++)
12136 {
2cf0635d 12137 Elf_Internal_Sym * psym;
861fb55a
DJ		 12138
12139 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12140 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12141 printf (" ");
12142 print_vma (psym->st_value, LONG_HEX);
12143 printf (" %-7s %3s ",
12144 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12145 get_symbol_index_type (psym->st_shndx));
12146 if (VALID_DYNAMIC_NAME (psym->st_name))
12147 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12148 else
2b692964 12149 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12150 printf ("\n");
12151 }
12152 printf ("\n");
12153
12154 if (data)
12155 free (data);
12156 free (rels);
12157 }
12158
252b5132
RH		 12159 return 1;
12160}
12161
047b2264 12162static int
2cf0635d 12163process_gnu_liblist (FILE * file)
047b2264 12164{
2cf0635d
NC		 12165 Elf_Internal_Shdr * section;
12166 Elf_Internal_Shdr * string_sec;
12167 Elf32_External_Lib * elib;
12168 char * strtab;
c256ffe7 12169 size_t strtab_size;
047b2264
JJ		 12170 size_t cnt;
12171 unsigned i;
12172
12173 if (! do_arch)
12174 return 0;
12175
12176 for (i = 0, section = section_headers;
12177 i < elf_header.e_shnum;
b34976b6 12178 i++, section++)
047b2264
JJ		 12179 {
12180 switch (section->sh_type)
12181 {
12182 case SHT_GNU_LIBLIST:
4fbb74a6 12183 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12184 break;
12185
3f5e193b
NC		 12186 elib = (Elf32_External_Lib *)
12187 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12188 _("liblist"));
047b2264
JJ		 12189
12190 if (elib == NULL)
12191 break;
4fbb74a6 12192 string_sec = section_headers + section->sh_link;
047b2264 12193
3f5e193b
NC		 12194 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12195 string_sec->sh_size,
12196 _("liblist string table"));
047b2264
JJ		 12197 if (strtab == NULL
12198 || section->sh_entsize != sizeof (Elf32_External_Lib))
12199 {
12200 free (elib);
2842702f 12201 free (strtab);
047b2264
JJ		 12202 break;
12203 }
59245841 12204 strtab_size = string_sec->sh_size;
047b2264
JJ		 12205
12206 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12207 SECTION_NAME (section),
0af1713e 12208 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12209
2b692964 12210 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12211
12212 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12213 ++cnt)
12214 {
12215 Elf32_Lib liblist;
91d6fa6a 12216 time_t atime;
047b2264 12217 char timebuf[20];
2cf0635d 12218 struct tm * tmp;
047b2264
JJ		 12219
12220 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12221 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12222 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12223 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12224 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12225
91d6fa6a 12226 tmp = gmtime (&atime);
e9e44622
JJ		 12227 snprintf (timebuf, sizeof (timebuf),
12228 "%04u-%02u-%02uT%02u:%02u:%02u",
12229 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12230 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12231
12232 printf ("%3lu: ", (unsigned long) cnt);
12233 if (do_wide)
c256ffe7 12234 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12235 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12236 else
c256ffe7 12237 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12238 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12239 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12240 liblist.l_version, liblist.l_flags);
12241 }
12242
12243 free (elib);
2842702f 12244 free (strtab);
047b2264
JJ		 12245 }
12246 }
12247
12248 return 1;
12249}
12250
9437c45b 12251static const char *
d3ba0551 12252get_note_type (unsigned e_type)
779fe533
NC		 12253{
12254 static char buff[64];
103f02d3 12255
1ec5cd37
NC		 12256 if (elf_header.e_type == ET_CORE)
12257 switch (e_type)
12258 {
57346661 12259 case NT_AUXV:
1ec5cd37 12260 return _("NT_AUXV (auxiliary vector)");
57346661 12261 case NT_PRSTATUS:
1ec5cd37 12262 return _("NT_PRSTATUS (prstatus structure)");
57346661 12263 case NT_FPREGSET:
1ec5cd37 12264 return _("NT_FPREGSET (floating point registers)");
57346661 12265 case NT_PRPSINFO:
1ec5cd37 12266 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12267 case NT_TASKSTRUCT:
1ec5cd37 12268 return _("NT_TASKSTRUCT (task structure)");
57346661 12269 case NT_PRXFPREG:
1ec5cd37 12270 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12271 case NT_PPC_VMX:
12272 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12273 case NT_PPC_VSX:
12274 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12275 case NT_X86_XSTATE:
12276 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12277 case NT_S390_HIGH_GPRS:
12278 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12279 case NT_S390_TIMER:
12280 return _("NT_S390_TIMER (s390 timer register)");
12281 case NT_S390_TODCMP:
12282 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12283 case NT_S390_TODPREG:
12284 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12285 case NT_S390_CTRS:
12286 return _("NT_S390_CTRS (s390 control registers)");
12287 case NT_S390_PREFIX:
12288 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12289 case NT_ARM_VFP:
12290 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12291 case NT_PSTATUS:
1ec5cd37 12292 return _("NT_PSTATUS (pstatus structure)");
57346661 12293 case NT_FPREGS:
1ec5cd37 12294 return _("NT_FPREGS (floating point registers)");
57346661 12295 case NT_PSINFO:
1ec5cd37 12296 return _("NT_PSINFO (psinfo structure)");
57346661 12297 case NT_LWPSTATUS:
1ec5cd37 12298 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12299 case NT_LWPSINFO:
1ec5cd37 12300 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12301 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12302 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12303 default:
12304 break;
12305 }
12306 else
12307 switch (e_type)
12308 {
12309 case NT_VERSION:
12310 return _("NT_VERSION (version)");
12311 case NT_ARCH:
12312 return _("NT_ARCH (architecture)");
12313 default:
12314 break;
12315 }
12316
e9e44622 12317 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12318 return buff;
779fe533
NC		 12319}
12320
1118d252
RM		 12321static const char *
12322get_gnu_elf_note_type (unsigned e_type)
12323{
12324 static char buff[64];
12325
12326 switch (e_type)
12327 {
12328 case NT_GNU_ABI_TAG:
12329 return _("NT_GNU_ABI_TAG (ABI version tag)");
12330 case NT_GNU_HWCAP:
12331 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12332 case NT_GNU_BUILD_ID:
12333 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12334 case NT_GNU_GOLD_VERSION:
12335 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12336 default:
12337 break;
12338 }
12339
12340 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12341 return buff;
12342}
12343
664f90a3
TT		 12344static int
12345print_gnu_note (Elf_Internal_Note *pnote)
12346{
12347 switch (pnote->type)
12348 {
12349 case NT_GNU_BUILD_ID:
12350 {
12351 unsigned long i;
12352
12353 printf (_(" Build ID: "));
12354 for (i = 0; i < pnote->descsz; ++i)
12355 printf ("%02x", pnote->descdata[i] & 0xff);
12356 printf (_("\n"));
12357 }
12358 break;
12359
12360 case NT_GNU_ABI_TAG:
12361 {
12362 unsigned long os, major, minor, subminor;
12363 const char *osname;
12364
12365 os = byte_get ((unsigned char *) pnote->descdata, 4);
12366 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12367 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12368 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12369
12370 switch (os)
12371 {
12372 case GNU_ABI_TAG_LINUX:
12373 osname = "Linux";
12374 break;
12375 case GNU_ABI_TAG_HURD:
12376 osname = "Hurd";
12377 break;
12378 case GNU_ABI_TAG_SOLARIS:
12379 osname = "Solaris";
12380 break;
12381 case GNU_ABI_TAG_FREEBSD:
12382 osname = "FreeBSD";
12383 break;
12384 case GNU_ABI_TAG_NETBSD:
12385 osname = "NetBSD";
12386 break;
12387 default:
12388 osname = "Unknown";
12389 break;
12390 }
12391
12392 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12393 major, minor, subminor);
12394 }
12395 break;
12396 }
12397
12398 return 1;
12399}
12400
9437c45b 12401static const char *
d3ba0551 12402get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12403{
12404 static char buff[64];
12405
b4db1224 12406 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12407 {
12408 /* NetBSD core "procinfo" structure. */
12409 return _("NetBSD procinfo structure");
12410 }
12411
12412 /* As of Jan 2002 there are no other machine-independent notes
12413 defined for NetBSD core files. If the note type is less
12414 than the start of the machine-dependent note types, we don't
12415 understand it. */
12416
b4db1224 12417 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12418 {
e9e44622 12419 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12420 return buff;
12421 }
12422
12423 switch (elf_header.e_machine)
12424 {
12425 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12426 and PT_GETFPREGS == mach+2. */
12427
12428 case EM_OLD_ALPHA:
12429 case EM_ALPHA:
12430 case EM_SPARC:
12431 case EM_SPARC32PLUS:
12432 case EM_SPARCV9:
12433 switch (e_type)
12434 {
2b692964 12435 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12436 return _("PT_GETREGS (reg structure)");
2b692964 12437 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12438 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12439 default:
12440 break;
12441 }
12442 break;
12443
12444 /* On all other arch's, PT_GETREGS == mach+1 and
12445 PT_GETFPREGS == mach+3. */
12446 default:
12447 switch (e_type)
12448 {
2b692964 12449 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12450 return _("PT_GETREGS (reg structure)");
2b692964 12451 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12452 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12453 default:
12454 break;
12455 }
12456 }
12457
e9e44622
JJ		 12458 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12459 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12460 return buff;
12461}
12462
70616151
TT		 12463static const char *
12464get_stapsdt_note_type (unsigned e_type)
12465{
12466 static char buff[64];
12467
12468 switch (e_type)
12469 {
12470 case NT_STAPSDT:
12471 return _("NT_STAPSDT (SystemTap probe descriptors)");
12472
12473 default:
12474 break;
12475 }
12476
12477 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12478 return buff;
12479}
12480
c6a9fc58
TT		 12481static int
12482print_stapsdt_note (Elf_Internal_Note *pnote)
12483{
12484 int addr_size = is_32bit_elf ? 4 : 8;
12485 char *data = pnote->descdata;
12486 char *data_end = pnote->descdata + pnote->descsz;
12487 bfd_vma pc, base_addr, semaphore;
12488 char *provider, *probe, *arg_fmt;
12489
12490 pc = byte_get ((unsigned char *) data, addr_size);
12491 data += addr_size;
12492 base_addr = byte_get ((unsigned char *) data, addr_size);
12493 data += addr_size;
12494 semaphore = byte_get ((unsigned char *) data, addr_size);
12495 data += addr_size;
12496
12497 provider = data;
12498 data += strlen (data) + 1;
12499 probe = data;
12500 data += strlen (data) + 1;
12501 arg_fmt = data;
12502 data += strlen (data) + 1;
12503
12504 printf (_(" Provider: %s\n"), provider);
12505 printf (_(" Name: %s\n"), probe);
12506 printf (_(" Location: "));
12507 print_vma (pc, FULL_HEX);
12508 printf (_(", Base: "));
12509 print_vma (base_addr, FULL_HEX);
12510 printf (_(", Semaphore: "));
12511 print_vma (semaphore, FULL_HEX);
12512 printf (_("\n"));
12513 printf (_(" Arguments: %s\n"), arg_fmt);
12514
12515 return data == data_end;
12516}
12517
00e98fc7
TG		 12518static const char *
12519get_ia64_vms_note_type (unsigned e_type)
12520{
12521 static char buff[64];
12522
12523 switch (e_type)
12524 {
12525 case NT_VMS_MHD:
12526 return _("NT_VMS_MHD (module header)");
12527 case NT_VMS_LNM:
12528 return _("NT_VMS_LNM (language name)");
12529 case NT_VMS_SRC:
12530 return _("NT_VMS_SRC (source files)");
12531 case NT_VMS_TITLE:
12532 return _("NT_VMS_TITLE");
12533 case NT_VMS_EIDC:
12534 return _("NT_VMS_EIDC (consistency check)");
12535 case NT_VMS_FPMODE:
12536 return _("NT_VMS_FPMODE (FP mode)");
12537 case NT_VMS_LINKTIME:
12538 return _("NT_VMS_LINKTIME");
12539 case NT_VMS_IMGNAM:
12540 return _("NT_VMS_IMGNAM (image name)");
12541 case NT_VMS_IMGID:
12542 return _("NT_VMS_IMGID (image id)");
12543 case NT_VMS_LINKID:
12544 return _("NT_VMS_LINKID (link id)");
12545 case NT_VMS_IMGBID:
12546 return _("NT_VMS_IMGBID (build id)");
12547 case NT_VMS_GSTNAM:
12548 return _("NT_VMS_GSTNAM (sym table name)");
12549 case NT_VMS_ORIG_DYN:
12550 return _("NT_VMS_ORIG_DYN");
12551 case NT_VMS_PATCHTIME:
12552 return _("NT_VMS_PATCHTIME");
12553 default:
12554 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12555 return buff;
12556 }
12557}
12558
12559static int
12560print_ia64_vms_note (Elf_Internal_Note * pnote)
12561{
12562 switch (pnote->type)
12563 {
12564 case NT_VMS_MHD:
12565 if (pnote->descsz > 36)
12566 {
12567 size_t l = strlen (pnote->descdata + 34);
12568 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12569 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12570 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12571 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12572 }
12573 else
12574 printf (_(" Invalid size\n"));
12575 break;
12576 case NT_VMS_LNM:
12577 printf (_(" Language: %s\n"), pnote->descdata);
12578 break;
12579#ifdef BFD64
12580 case NT_VMS_FPMODE:
12581 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12582 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12583 break;
12584 case NT_VMS_LINKTIME:
12585 printf (_(" Link time: "));
12586 print_vms_time
12587 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12588 printf ("\n");
12589 break;
12590 case NT_VMS_PATCHTIME:
12591 printf (_(" Patch time: "));
12592 print_vms_time
12593 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12594 printf ("\n");
12595 break;
12596 case NT_VMS_ORIG_DYN:
12597 printf (_(" Major id: %u, minor id: %u\n"),
12598 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12599 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12600 printf (_(" Manip date : "));
12601 print_vms_time
12602 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12603 printf (_("\n"
12604 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12605 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12606 printf (_(" Header flags: 0x%08x\n"),
12607 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12608 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12609 break;
12610#endif
12611 case NT_VMS_IMGNAM:
12612 printf (_(" Image name: %s\n"), pnote->descdata);
12613 break;
12614 case NT_VMS_GSTNAM:
12615 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12616 break;
12617 case NT_VMS_IMGID:
12618 printf (_(" Image id: %s\n"), pnote->descdata);
12619 break;
12620 case NT_VMS_LINKID:
12621 printf (_(" Linker id: %s\n"), pnote->descdata);
12622 break;
12623 default:
12624 break;
12625 }
12626 return 1;
12627}
12628
6d118b09
NC		 12629/* Note that by the ELF standard, the name field is already null byte
12630 terminated, and namesz includes the terminating null byte.
12631 I.E. the value of namesz for the name "FSF" is 4.
12632
e3c8793a 12633 If the value of namesz is zero, there is no name present. */
779fe533 12634static int
2cf0635d 12635process_note (Elf_Internal_Note * pnote)
779fe533 12636{
2cf0635d
NC		 12637 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12638 const char * nt;
9437c45b
JT		 12639
12640 if (pnote->namesz == 0)
1ec5cd37
NC		 12641 /* If there is no note name, then use the default set of
12642 note type strings. */
12643 nt = get_note_type (pnote->type);
12644
1118d252
RM		 12645 else if (const_strneq (pnote->namedata, "GNU"))
12646 /* GNU-specific object file notes. */
12647 nt = get_gnu_elf_note_type (pnote->type);
12648
0112cd26 12649 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12650 /* NetBSD-specific core file notes. */
12651 nt = get_netbsd_elfcore_note_type (pnote->type);
12652
b15fa79e
AM		 12653 else if (strneq (pnote->namedata, "SPU/", 4))
12654 {
12655 /* SPU-specific core file notes. */
12656 nt = pnote->namedata + 4;
12657 name = "SPU";
12658 }
12659
00e98fc7
TG		 12660 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12661 /* VMS/ia64-specific file notes. */
12662 nt = get_ia64_vms_note_type (pnote->type);
12663
70616151
TT		 12664 else if (const_strneq (pnote->namedata, "stapsdt"))
12665 nt = get_stapsdt_note_type (pnote->type);
12666
9437c45b 12667 else
1ec5cd37
NC		 12668 /* Don't recognize this note name; just use the default set of
12669 note type strings. */
00e98fc7 12670 nt = get_note_type (pnote->type);
9437c45b 12671
2aee03ae 12672 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12673
12674 if (const_strneq (pnote->namedata, "IPF/VMS"))
12675 return print_ia64_vms_note (pnote);
664f90a3
TT		 12676 else if (const_strneq (pnote->namedata, "GNU"))
12677 return print_gnu_note (pnote);
c6a9fc58
TT		 12678 else if (const_strneq (pnote->namedata, "stapsdt"))
12679 return print_stapsdt_note (pnote);
00e98fc7
TG		 12680 else
12681 return 1;
779fe533
NC		 12682}
12683
6d118b09 12684
779fe533 12685static int
2cf0635d 12686process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12687{
2cf0635d
NC		 12688 Elf_External_Note * pnotes;
12689 Elf_External_Note * external;
b34976b6 12690 int res = 1;
103f02d3 12691
779fe533
NC		 12692 if (length <= 0)
12693 return 0;
103f02d3 12694
3f5e193b
NC		 12695 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12696 _("notes"));
dd24e3da 12697 if (pnotes == NULL)
a6e9f9df 12698 return 0;
779fe533 12699
103f02d3 12700 external = pnotes;
103f02d3 12701
305c7206 12702 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12703 (unsigned long) offset, (unsigned long) length);
2aee03ae 12704 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 12705
2cf0635d 12706 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12707 {
2cf0635d 12708 Elf_External_Note * next;
b34976b6 12709 Elf_Internal_Note inote;
2cf0635d 12710 char * temp = NULL;
6d118b09 12711
00e98fc7
TG		 12712 if (!is_ia64_vms ())
12713 {
12714 inote.type = BYTE_GET (external->type);
12715 inote.namesz = BYTE_GET (external->namesz);
12716 inote.namedata = external->name;
12717 inote.descsz = BYTE_GET (external->descsz);
12718 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12719 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12720
12721 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12722 }
12723 else
12724 {
12725 Elf64_External_VMS_Note *vms_external;
12726
12727 vms_external = (Elf64_External_VMS_Note *)external;
12728 inote.type = BYTE_GET (vms_external->type);
12729 inote.namesz = BYTE_GET (vms_external->namesz);
12730 inote.namedata = vms_external->name;
12731 inote.descsz = BYTE_GET (vms_external->descsz);
12732 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12733 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12734
12735 next = (Elf_External_Note *)
12736 (inote.descdata + align_power (inote.descsz, 3));
12737 }
3e55a963 12738
dd24e3da
NC		 12739 if ( ((char *) next > ((char *) pnotes) + length)
12740 || ((char *) next < (char *) pnotes))
3e55a963 12741 {
0fd3a477 12742 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12743 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12744 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12745 inote.type, inote.namesz, inote.descsz);
12746 break;
12747 }
12748
12749 external = next;
6d118b09 12750
dd24e3da
NC		 12751 /* Prevent out-of-bounds indexing. */
12752 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12753 || inote.namedata + inote.namesz < inote.namedata)
12754 {
12755 warn (_("corrupt note found at offset %lx into core notes\n"),
12756 (unsigned long) ((char *) external - (char *) pnotes));
12757 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12758 inote.type, inote.namesz, inote.descsz);
12759 break;
12760 }
12761
6d118b09
NC		 12762 /* Verify that name is null terminated. It appears that at least
12763 one version of Linux (RedHat 6.0) generates corefiles that don't
12764 comply with the ELF spec by failing to include the null byte in
12765 namesz. */
12766 if (inote.namedata[inote.namesz] != '\0')
12767 {
3f5e193b 12768 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 12769
6d118b09
NC		 12770 if (temp == NULL)
12771 {
12772 error (_("Out of memory\n"));
12773 res = 0;
12774 break;
12775 }
76da6bbe 12776
6d118b09
NC		 12777 strncpy (temp, inote.namedata, inote.namesz);
12778 temp[inote.namesz] = 0;
76da6bbe 12779
6d118b09
NC		 12780 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12781 inote.namedata = temp;
12782 }
12783
12784 res &= process_note (& inote);
103f02d3 12785
6d118b09
NC		 12786 if (temp != NULL)
12787 {
12788 free (temp);
12789 temp = NULL;
12790 }
779fe533
NC		 12791 }
12792
12793 free (pnotes);
103f02d3 12794
779fe533
NC		 12795 return res;
12796}
12797
12798static int
2cf0635d 12799process_corefile_note_segments (FILE * file)
779fe533 12800{
2cf0635d 12801 Elf_Internal_Phdr * segment;
b34976b6
AM		 12802 unsigned int i;
12803 int res = 1;
103f02d3 12804
d93f0186 12805 if (! get_program_headers (file))
779fe533 12806 return 0;
103f02d3 12807
779fe533
NC		 12808 for (i = 0, segment = program_headers;
12809 i < elf_header.e_phnum;
b34976b6 12810 i++, segment++)
779fe533
NC		 12811 {
12812 if (segment->p_type == PT_NOTE)
103f02d3 12813 res &= process_corefile_note_segment (file,
30800947
NC		 12814 (bfd_vma) segment->p_offset,
12815 (bfd_vma) segment->p_filesz);
779fe533 12816 }
103f02d3 12817
779fe533
NC		 12818 return res;
12819}
12820
12821static int
2cf0635d 12822process_note_sections (FILE * file)
1ec5cd37 12823{
2cf0635d 12824 Elf_Internal_Shdr * section;
1ec5cd37
NC		 12825 unsigned long i;
12826 int res = 1;
12827
12828 for (i = 0, section = section_headers;
12829 i < elf_header.e_shnum;
12830 i++, section++)
12831 if (section->sh_type == SHT_NOTE)
12832 res &= process_corefile_note_segment (file,
12833 (bfd_vma) section->sh_offset,
12834 (bfd_vma) section->sh_size);
12835
12836 return res;
12837}
12838
12839static int
2cf0635d 12840process_notes (FILE * file)
779fe533
NC		 12841{
12842 /* If we have not been asked to display the notes then do nothing. */
12843 if (! do_notes)
12844 return 1;
103f02d3 12845
779fe533 12846 if (elf_header.e_type != ET_CORE)
1ec5cd37 12847 return process_note_sections (file);
103f02d3 12848
779fe533 12849 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 12850 if (elf_header.e_phnum > 0)
12851 return process_corefile_note_segments (file);
779fe533 12852
1ec5cd37
NC		 12853 printf (_("No note segments present in the core file.\n"));
12854 return 1;
779fe533
NC		 12855}
12856
252b5132 12857static int
2cf0635d 12858process_arch_specific (FILE * file)
252b5132 12859{
a952a375
NC		 12860 if (! do_arch)
12861 return 1;
12862
252b5132
RH		 12863 switch (elf_header.e_machine)
12864 {
11c1ff18
PB		 12865 case EM_ARM:
12866 return process_arm_specific (file);
252b5132 12867 case EM_MIPS:
4fe85591 12868 case EM_MIPS_RS3_LE:
252b5132
RH		 12869 return process_mips_specific (file);
12870 break;
34c8bcba
JM		 12871 case EM_PPC:
12872 return process_power_specific (file);
12873 break;
59e6276b
JM		 12874 case EM_TI_C6000:
12875 return process_tic6x_specific (file);
12876 break;
252b5132
RH		 12877 default:
12878 break;
12879 }
12880 return 1;
12881}
12882
12883static int
2cf0635d 12884get_file_header (FILE * file)
252b5132 12885{
9ea033b2
NC		 12886 /* Read in the identity array. */
12887 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 12888 return 0;
12889
9ea033b2 12890 /* Determine how to read the rest of the header. */
b34976b6 12891 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 12892 {
12893 default: /* fall through */
12894 case ELFDATANONE: /* fall through */
adab8cdc
AO		 12895 case ELFDATA2LSB:
12896 byte_get = byte_get_little_endian;
12897 byte_put = byte_put_little_endian;
12898 break;
12899 case ELFDATA2MSB:
12900 byte_get = byte_get_big_endian;
12901 byte_put = byte_put_big_endian;
12902 break;
9ea033b2
NC		 12903 }
12904
12905 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 12906 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 12907
12908 /* Read in the rest of the header. */
12909 if (is_32bit_elf)
12910 {
12911 Elf32_External_Ehdr ehdr32;
252b5132 12912
9ea033b2
NC		 12913 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12914 return 0;
103f02d3 12915
9ea033b2
NC		 12916 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12917 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12918 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12919 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12920 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12921 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12922 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12923 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12924 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12925 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12926 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12927 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12928 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12929 }
252b5132 12930 else
9ea033b2
NC		 12931 {
12932 Elf64_External_Ehdr ehdr64;
a952a375
NC		 12933
12934 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12935 we will not be able to cope with the 64bit data found in
12936 64 ELF files. Detect this now and abort before we start
50c2245b 12937 overwriting things. */
a952a375
NC		 12938 if (sizeof (bfd_vma) < 8)
12939 {
e3c8793a
NC		 12940 error (_("This instance of readelf has been built without support for a\n\
1294164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 12942 return 0;
12943 }
103f02d3 12944
9ea033b2
NC		 12945 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12946 return 0;
103f02d3 12947
9ea033b2
NC		 12948 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12949 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12950 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 12951 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12952 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12953 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 12954 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12955 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12956 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12957 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12958 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12959 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12960 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12961 }
252b5132 12962
7ece0d85
JJ		 12963 if (elf_header.e_shoff)
12964 {
12965 /* There may be some extensions in the first section header. Don't
12966 bomb if we can't read it. */
12967 if (is_32bit_elf)
12968 get_32bit_section_headers (file, 1);
12969 else
12970 get_64bit_section_headers (file, 1);
12971 }
560f3c1c 12972
252b5132
RH		 12973 return 1;
12974}
12975
fb52b2f4
NC		 12976/* Process one ELF object file according to the command line options.
12977 This file may actually be stored in an archive. The file is
12978 positioned at the start of the ELF object. */
12979
ff78d6d6 12980static int
2cf0635d 12981process_object (char * file_name, FILE * file)
252b5132 12982{
252b5132
RH		 12983 unsigned int i;
12984
252b5132
RH		 12985 if (! get_file_header (file))
12986 {
12987 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 12988 return 1;
252b5132
RH		 12989 }
12990
12991 /* Initialise per file variables. */
60bca95a 12992 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 12993 version_info[i] = 0;
12994
60bca95a 12995 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 12996 dynamic_info[i] = 0;
5115b233 12997 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 12998
12999 /* Process the file. */
13000 if (show_name)
13001 printf (_("\nFile: %s\n"), file_name);
13002
18bd398b
NC		 13003 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13004 Note we do this even if cmdline_dump_sects is empty because we
13005 must make sure that the dump_sets array is zeroed out before each
13006 object file is processed. */
13007 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13008 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13009
13010 if (num_cmdline_dump_sects > 0)
13011 {
13012 if (num_dump_sects == 0)
13013 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13014 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13015
13016 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13017 memcpy (dump_sects, cmdline_dump_sects,
13018 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13019 }
d70c5fc7 13020
252b5132 13021 if (! process_file_header ())
fb52b2f4 13022 return 1;
252b5132 13023
d1f5c6e3 13024 if (! process_section_headers (file))
2f62977e 13025 {
d1f5c6e3
L		 13026 /* Without loaded section headers we cannot process lots of
13027 things. */
2f62977e 13028 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13029
2f62977e 13030 if (! do_using_dynamic)
2c610e4b 13031 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13032 }
252b5132 13033
d1f5c6e3
L		 13034 if (! process_section_groups (file))
13035 {
13036 /* Without loaded section groups we cannot process unwind. */
13037 do_unwind = 0;
13038 }
13039
2f62977e 13040 if (process_program_headers (file))
b2d38a17 13041 process_dynamic_section (file);
252b5132
RH		 13042
13043 process_relocs (file);
13044
4d6ed7c8
NC		 13045 process_unwind (file);
13046
252b5132
RH		 13047 process_symbol_table (file);
13048
13049 process_syminfo (file);
13050
13051 process_version_sections (file);
13052
13053 process_section_contents (file);
f5842774 13054
1ec5cd37 13055 process_notes (file);
103f02d3 13056
047b2264
JJ		 13057 process_gnu_liblist (file);
13058
252b5132
RH		 13059 process_arch_specific (file);
13060
d93f0186
NC		 13061 if (program_headers)
13062 {
13063 free (program_headers);
13064 program_headers = NULL;
13065 }
13066
252b5132
RH		 13067 if (section_headers)
13068 {
13069 free (section_headers);
13070 section_headers = NULL;
13071 }
13072
13073 if (string_table)
13074 {
13075 free (string_table);
13076 string_table = NULL;
d40ac9bd 13077 string_table_length = 0;
252b5132
RH		 13078 }
13079
13080 if (dynamic_strings)
13081 {
13082 free (dynamic_strings);
13083 dynamic_strings = NULL;
d79b3d50 13084 dynamic_strings_length = 0;
252b5132
RH		 13085 }
13086
13087 if (dynamic_symbols)
13088 {
13089 free (dynamic_symbols);
13090 dynamic_symbols = NULL;
19936277 13091 num_dynamic_syms = 0;
252b5132
RH		 13092 }
13093
13094 if (dynamic_syminfo)
13095 {
13096 free (dynamic_syminfo);
13097 dynamic_syminfo = NULL;
13098 }
ff78d6d6 13099
293c573e
MR		 13100 if (dynamic_section)
13101 {
13102 free (dynamic_section);
13103 dynamic_section = NULL;
13104 }
13105
e4b17d5c
L		 13106 if (section_headers_groups)
13107 {
13108 free (section_headers_groups);
13109 section_headers_groups = NULL;
13110 }
13111
13112 if (section_groups)
13113 {
2cf0635d
NC		 13114 struct group_list * g;
13115 struct group_list * next;
e4b17d5c
L		 13116
13117 for (i = 0; i < group_count; i++)
13118 {
13119 for (g = section_groups [i].root; g != NULL; g = next)
13120 {
13121 next = g->next;
13122 free (g);
13123 }
13124 }
13125
13126 free (section_groups);
13127 section_groups = NULL;
13128 }
13129
19e6b90e 13130 free_debug_memory ();
18bd398b 13131
ff78d6d6 13132 return 0;
252b5132
RH		 13133}
13134
2cf0635d
NC		 13135/* Process an ELF archive.
13136 On entry the file is positioned just after the ARMAG string. */
13137
13138static int
13139process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13140{
13141 struct archive_info arch;
13142 struct archive_info nested_arch;
13143 size_t got;
2cf0635d
NC		 13144 int ret;
13145
13146 show_name = 1;
13147
13148 /* The ARCH structure is used to hold information about this archive. */
13149 arch.file_name = NULL;
13150 arch.file = NULL;
13151 arch.index_array = NULL;
13152 arch.sym_table = NULL;
13153 arch.longnames = NULL;
13154
13155 /* The NESTED_ARCH structure is used as a single-item cache of information
13156 about a nested archive (when members of a thin archive reside within
13157 another regular archive file). */
13158 nested_arch.file_name = NULL;
13159 nested_arch.file = NULL;
13160 nested_arch.index_array = NULL;
13161 nested_arch.sym_table = NULL;
13162 nested_arch.longnames = NULL;
13163
13164 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13165 {
13166 ret = 1;
13167 goto out;
4145f1d5 13168 }
fb52b2f4 13169
4145f1d5
NC		 13170 if (do_archive_index)
13171 {
2cf0635d 13172 if (arch.sym_table == NULL)
4145f1d5
NC		 13173 error (_("%s: unable to dump the index as none was found\n"), file_name);
13174 else
13175 {
2cf0635d 13176 unsigned int i, l;
4145f1d5
NC		 13177 unsigned long current_pos;
13178
13179 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 13180 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 13181 current_pos = ftell (file);
13182
2cf0635d 13183 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13184 {
2cf0635d
NC		 13185 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13186 {
13187 char * member_name;
4145f1d5 13188
2cf0635d
NC		 13189 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13190
13191 if (member_name != NULL)
13192 {
13193 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13194
13195 if (qualified_name != NULL)
13196 {
13197 printf (_("Binary %s contains:\n"), qualified_name);
13198 free (qualified_name);
13199 }
4145f1d5
NC		 13200 }
13201 }
2cf0635d
NC		 13202
13203 if (l >= arch.sym_size)
4145f1d5
NC		 13204 {
13205 error (_("%s: end of the symbol table reached before the end of the index\n"),
13206 file_name);
cb8f3167 13207 break;
4145f1d5 13208 }
2cf0635d
NC		 13209 printf ("\t%s\n", arch.sym_table + l);
13210 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13211 }
13212
2cf0635d
NC		 13213 if (l & 01)
13214 ++l;
13215 if (l < arch.sym_size)
4145f1d5
NC		 13216 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13217 file_name);
13218
4145f1d5
NC		 13219 if (fseek (file, current_pos, SEEK_SET) != 0)
13220 {
13221 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13222 ret = 1;
13223 goto out;
4145f1d5 13224 }
fb52b2f4 13225 }
4145f1d5
NC		 13226
13227 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13228 && !do_segments && !do_header && !do_dump && !do_version
13229 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13230 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13231 {
13232 ret = 0; /* Archive index only. */
13233 goto out;
13234 }
fb52b2f4
NC		 13235 }
13236
d989285c 13237 ret = 0;
fb52b2f4
NC		 13238
13239 while (1)
13240 {
2cf0635d
NC		 13241 char * name;
13242 size_t namelen;
13243 char * qualified_name;
13244
13245 /* Read the next archive header. */
13246 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13247 {
13248 error (_("%s: failed to seek to next archive header\n"), file_name);
13249 return 1;
13250 }
13251 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13252 if (got != sizeof arch.arhdr)
13253 {
13254 if (got == 0)
13255 break;
13256 error (_("%s: failed to read archive header\n"), file_name);
13257 ret = 1;
13258 break;
13259 }
13260 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13261 {
13262 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13263 ret = 1;
13264 break;
13265 }
13266
13267 arch.next_arhdr_offset += sizeof arch.arhdr;
13268
13269 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13270 if (archive_file_size & 01)
13271 ++archive_file_size;
13272
13273 name = get_archive_member_name (&arch, &nested_arch);
13274 if (name == NULL)
fb52b2f4 13275 {
0fd3a477 13276 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13277 ret = 1;
13278 break;
fb52b2f4 13279 }
2cf0635d 13280 namelen = strlen (name);
fb52b2f4 13281
2cf0635d
NC		 13282 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13283 if (qualified_name == NULL)
fb52b2f4 13284 {
2cf0635d 13285 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13286 ret = 1;
13287 break;
fb52b2f4
NC		 13288 }
13289
2cf0635d
NC		 13290 if (is_thin_archive && arch.nested_member_origin == 0)
13291 {
13292 /* This is a proxy for an external member of a thin archive. */
13293 FILE * member_file;
13294 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13295 if (member_file_name == NULL)
13296 {
13297 ret = 1;
13298 break;
13299 }
13300
13301 member_file = fopen (member_file_name, "rb");
13302 if (member_file == NULL)
13303 {
13304 error (_("Input file '%s' is not readable.\n"), member_file_name);
13305 free (member_file_name);
13306 ret = 1;
13307 break;
13308 }
13309
13310 archive_file_offset = arch.nested_member_origin;
13311
13312 ret |= process_object (qualified_name, member_file);
13313
13314 fclose (member_file);
13315 free (member_file_name);
13316 }
13317 else if (is_thin_archive)
13318 {
13319 /* This is a proxy for a member of a nested archive. */
13320 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13321
13322 /* The nested archive file will have been opened and setup by
13323 get_archive_member_name. */
13324 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13325 {
13326 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13327 ret = 1;
13328 break;
13329 }
13330
13331 ret |= process_object (qualified_name, nested_arch.file);
13332 }
13333 else
13334 {
13335 archive_file_offset = arch.next_arhdr_offset;
13336 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13337
2cf0635d
NC		 13338 ret |= process_object (qualified_name, file);
13339 }
fb52b2f4 13340
2b52916e
L		 13341 if (dump_sects != NULL)
13342 {
13343 free (dump_sects);
13344 dump_sects = NULL;
13345 num_dump_sects = 0;
13346 }
13347
2cf0635d 13348 free (qualified_name);
fb52b2f4
NC		 13349 }
13350
4145f1d5 13351 out:
2cf0635d
NC		 13352 if (nested_arch.file != NULL)
13353 fclose (nested_arch.file);
13354 release_archive (&nested_arch);
13355 release_archive (&arch);
fb52b2f4 13356
d989285c 13357 return ret;
fb52b2f4
NC		 13358}
13359
13360static int
2cf0635d 13361process_file (char * file_name)
fb52b2f4 13362{
2cf0635d 13363 FILE * file;
fb52b2f4
NC		 13364 struct stat statbuf;
13365 char armag[SARMAG];
13366 int ret;
13367
13368 if (stat (file_name, &statbuf) < 0)
13369 {
f24ddbdd
NC		 13370 if (errno == ENOENT)
13371 error (_("'%s': No such file\n"), file_name);
13372 else
13373 error (_("Could not locate '%s'. System error message: %s\n"),
13374 file_name, strerror (errno));
13375 return 1;
13376 }
13377
13378 if (! S_ISREG (statbuf.st_mode))
13379 {
13380 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13381 return 1;
13382 }
13383
13384 file = fopen (file_name, "rb");
13385 if (file == NULL)
13386 {
f24ddbdd 13387 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13388 return 1;
13389 }
13390
13391 if (fread (armag, SARMAG, 1, file) != 1)
13392 {
4145f1d5 13393 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13394 fclose (file);
13395 return 1;
13396 }
13397
13398 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13399 ret = process_archive (file_name, file, FALSE);
13400 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13401 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13402 else
13403 {
4145f1d5
NC		 13404 if (do_archive_index)
13405 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13406 file_name);
13407
fb52b2f4
NC		 13408 rewind (file);
13409 archive_file_size = archive_file_offset = 0;
13410 ret = process_object (file_name, file);
13411 }
13412
13413 fclose (file);
13414
13415 return ret;
13416}
13417
252b5132
RH		 13418#ifdef SUPPORT_DISASSEMBLY
13419/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13420 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13421 symbols. */
252b5132
RH		 13422
13423void
2cf0635d 13424print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13425{
13426 fprintf (outfile,"0x%8.8x", addr);
13427}
13428
e3c8793a 13429/* Needed by the i386 disassembler. */
252b5132
RH		 13430void
13431db_task_printsym (unsigned int addr)
13432{
13433 print_address (addr, stderr);
13434}
13435#endif
13436
13437int
2cf0635d 13438main (int argc, char ** argv)
252b5132 13439{
ff78d6d6
L		 13440 int err;
13441
252b5132
RH		 13442#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13443 setlocale (LC_MESSAGES, "");
3882b010
L		 13444#endif
13445#if defined (HAVE_SETLOCALE)
13446 setlocale (LC_CTYPE, "");
252b5132
RH		 13447#endif
13448 bindtextdomain (PACKAGE, LOCALEDIR);
13449 textdomain (PACKAGE);
13450
869b9d07
MM		 13451 expandargv (&argc, &argv);
13452
252b5132
RH		 13453 parse_args (argc, argv);
13454
18bd398b 13455 if (num_dump_sects > 0)
59f14fc0 13456 {
18bd398b 13457 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13458 cmdline_dump_sects = (dump_type *)
13459 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13460 if (cmdline_dump_sects == NULL)
591a748a 13461 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13462 else
13463 {
09c11c86
NC		 13464 memcpy (cmdline_dump_sects, dump_sects,
13465 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13466 num_cmdline_dump_sects = num_dump_sects;
13467 }
13468 }
13469
18bd398b
NC		 13470 if (optind < (argc - 1))
13471 show_name = 1;
13472
ff78d6d6 13473 err = 0;
252b5132 13474 while (optind < argc)
18bd398b 13475 err |= process_file (argv[optind++]);
252b5132
RH		 13476
13477 if (dump_sects != NULL)
13478 free (dump_sects);
59f14fc0
AS		 13479 if (cmdline_dump_sects != NULL)
13480 free (cmdline_dump_sects);
252b5132 13481
ff78d6d6 13482 return err;
252b5132 13483}
A mirror of the official binutils-gdb repository