projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR gas/12931
[deliverable/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
e9e44622 3087 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
103f02d3 3088
252b5132
RH		 3089 return buff;
3090 }
3091}
3092
2979dc34 3093#define OPTION_DEBUG_DUMP 512
2c610e4b 3094#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3095#define OPTION_DWARF_DEPTH 514
3096#define OPTION_DWARF_START 515
2979dc34 3097
85b1c36d 3098static struct option options[] =
252b5132 3099{
b34976b6 3100 {"all", no_argument, 0, 'a'},
252b5132
RH		 3101 {"file-header", no_argument, 0, 'h'},
3102 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3103 {"headers", no_argument, 0, 'e'},
3104 {"histogram", no_argument, 0, 'I'},
3105 {"segments", no_argument, 0, 'l'},
3106 {"sections", no_argument, 0, 'S'},
252b5132 3107 {"section-headers", no_argument, 0, 'S'},
f5842774 3108 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3109 {"section-details", no_argument, 0, 't'},
595cf52e 3110 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3111 {"symbols", no_argument, 0, 's'},
3112 {"syms", no_argument, 0, 's'},
2c610e4b 3113 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3114 {"relocs", no_argument, 0, 'r'},
3115 {"notes", no_argument, 0, 'n'},
3116 {"dynamic", no_argument, 0, 'd'},
a952a375 3117 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3118 {"version-info", no_argument, 0, 'V'},
3119 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3120 {"unwind", no_argument, 0, 'u'},
4145f1d5 3121 {"archive-index", no_argument, 0, 'c'},
b34976b6 3122 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3123 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3124 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3125#ifdef SUPPORT_DISASSEMBLY
3126 {"instruction-dump", required_argument, 0, 'i'},
3127#endif
cf13d699 3128 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3129
fd2f0033
TT		 3130 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3131 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3132
b34976b6
AM		 3133 {"version", no_argument, 0, 'v'},
3134 {"wide", no_argument, 0, 'W'},
3135 {"help", no_argument, 0, 'H'},
3136 {0, no_argument, 0, 0}
252b5132
RH		 3137};
3138
3139static void
2cf0635d 3140usage (FILE * stream)
252b5132 3141{
92f01d61
JM		 3142 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3143 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3144 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3145 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3146 -h --file-header Display the ELF file header\n\
3147 -l --program-headers Display the program headers\n\
3148 --segments An alias for --program-headers\n\
3149 -S --section-headers Display the sections' header\n\
3150 --sections An alias for --section-headers\n\
f5842774 3151 -g --section-groups Display the section groups\n\
5477e8a0 3152 -t --section-details Display the section details\n\
8b53311e
NC		 3153 -e --headers Equivalent to: -h -l -S\n\
3154 -s --syms Display the symbol table\n\
3f08eb35 3155 --symbols An alias for --syms\n\
2c610e4b 3156 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3157 -n --notes Display the core notes (if present)\n\
3158 -r --relocs Display the relocations (if present)\n\
3159 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3160 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3161 -V --version-info Display the version sections (if present)\n\
3162 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3163 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3164 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3165 -x --hex-dump=<number|name>\n\
3166 Dump the contents of section <number|name> as bytes\n\
3167 -p --string-dump=<number|name>\n\
3168 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3169 -R --relocated-dump=<number|name>\n\
3170 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3171 -w[lLiaprmfFsoRt] or\n\
1ed06042 3172 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3173 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3174 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3175 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3176 fprintf (stream, _("\
3177 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3178 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3179 or deeper\n"));
252b5132 3180#ifdef SUPPORT_DISASSEMBLY
92f01d61 3181 fprintf (stream, _("\
09c11c86
NC		 3182 -i --instruction-dump=<number|name>\n\
3183 Disassemble the contents of section <number|name>\n"));
252b5132 3184#endif
92f01d61 3185 fprintf (stream, _("\
8b53311e
NC		 3186 -I --histogram Display histogram of bucket list lengths\n\
3187 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3188 @<file> Read options from <file>\n\
8b53311e
NC		 3189 -H --help Display this information\n\
3190 -v --version Display the version number of readelf\n"));
1118d252 3191
92f01d61
JM		 3192 if (REPORT_BUGS_TO[0] && stream == stdout)
3193 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3194
92f01d61 3195 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3196}
3197
18bd398b
NC		 3198/* Record the fact that the user wants the contents of section number
3199 SECTION to be displayed using the method(s) encoded as flags bits
3200 in TYPE. Note, TYPE can be zero if we are creating the array for
3201 the first time. */
3202
252b5132 3203static void
09c11c86 3204request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3205{
3206 if (section >= num_dump_sects)
3207 {
2cf0635d 3208 dump_type * new_dump_sects;
252b5132 3209
3f5e193b
NC		 3210 new_dump_sects = (dump_type *) calloc (section + 1,
3211 sizeof (* dump_sects));
252b5132
RH		 3212
3213 if (new_dump_sects == NULL)
591a748a 3214 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3215 else
3216 {
3217 /* Copy current flag settings. */
09c11c86 3218 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3219
3220 free (dump_sects);
3221
3222 dump_sects = new_dump_sects;
3223 num_dump_sects = section + 1;
3224 }
3225 }
3226
3227 if (dump_sects)
b34976b6 3228 dump_sects[section] |= type;
252b5132
RH		 3229
3230 return;
3231}
3232
aef1f6d0
DJ		 3233/* Request a dump by section name. */
3234
3235static void
2cf0635d 3236request_dump_byname (const char * section, dump_type type)
aef1f6d0 3237{
2cf0635d 3238 struct dump_list_entry * new_request;
aef1f6d0 3239
3f5e193b
NC		 3240 new_request = (struct dump_list_entry *)
3241 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3242 if (!new_request)
591a748a 3243 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3244
3245 new_request->name = strdup (section);
3246 if (!new_request->name)
591a748a 3247 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3248
3249 new_request->type = type;
3250
3251 new_request->next = dump_sects_byname;
3252 dump_sects_byname = new_request;
3253}
3254
cf13d699
NC		 3255static inline void
3256request_dump (dump_type type)
3257{
3258 int section;
3259 char * cp;
3260
3261 do_dump++;
3262 section = strtoul (optarg, & cp, 0);
3263
3264 if (! *cp && section >= 0)
3265 request_dump_bynumber (section, type);
3266 else
3267 request_dump_byname (optarg, type);
3268}
3269
3270
252b5132 3271static void
2cf0635d 3272parse_args (int argc, char ** argv)
252b5132
RH		 3273{
3274 int c;
3275
3276 if (argc < 2)
92f01d61 3277 usage (stderr);
252b5132
RH		 3278
3279 while ((c = getopt_long
cf13d699 3280 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3281 {
252b5132
RH		 3282 switch (c)
3283 {
3284 case 0:
3285 /* Long options. */
3286 break;
3287 case 'H':
92f01d61 3288 usage (stdout);
252b5132
RH		 3289 break;
3290
3291 case 'a':
b34976b6
AM		 3292 do_syms++;
3293 do_reloc++;
3294 do_unwind++;
3295 do_dynamic++;
3296 do_header++;
3297 do_sections++;
f5842774 3298 do_section_groups++;
b34976b6
AM		 3299 do_segments++;
3300 do_version++;
3301 do_histogram++;
3302 do_arch++;
3303 do_notes++;
252b5132 3304 break;
f5842774
L		 3305 case 'g':
3306 do_section_groups++;
3307 break;
5477e8a0 3308 case 't':
595cf52e 3309 case 'N':
5477e8a0
L		 3310 do_sections++;
3311 do_section_details++;
595cf52e 3312 break;
252b5132 3313 case 'e':
b34976b6
AM		 3314 do_header++;
3315 do_sections++;
3316 do_segments++;
252b5132 3317 break;
a952a375 3318 case 'A':
b34976b6 3319 do_arch++;
a952a375 3320 break;
252b5132 3321 case 'D':
b34976b6 3322 do_using_dynamic++;
252b5132
RH		 3323 break;
3324 case 'r':
b34976b6 3325 do_reloc++;
252b5132 3326 break;
4d6ed7c8 3327 case 'u':
b34976b6 3328 do_unwind++;
4d6ed7c8 3329 break;
252b5132 3330 case 'h':
b34976b6 3331 do_header++;
252b5132
RH		 3332 break;
3333 case 'l':
b34976b6 3334 do_segments++;
252b5132
RH		 3335 break;
3336 case 's':
b34976b6 3337 do_syms++;
252b5132
RH		 3338 break;
3339 case 'S':
b34976b6 3340 do_sections++;
252b5132
RH		 3341 break;
3342 case 'd':
b34976b6 3343 do_dynamic++;
252b5132 3344 break;
a952a375 3345 case 'I':
b34976b6 3346 do_histogram++;
a952a375 3347 break;
779fe533 3348 case 'n':
b34976b6 3349 do_notes++;
779fe533 3350 break;
4145f1d5
NC		 3351 case 'c':
3352 do_archive_index++;
3353 break;
252b5132 3354 case 'x':
cf13d699 3355 request_dump (HEX_DUMP);
aef1f6d0 3356 break;
09c11c86 3357 case 'p':
cf13d699
NC		 3358 request_dump (STRING_DUMP);
3359 break;
3360 case 'R':
3361 request_dump (RELOC_DUMP);
09c11c86 3362 break;
252b5132 3363 case 'w':
b34976b6 3364 do_dump++;
252b5132 3365 if (optarg == 0)
613ff48b
CC		 3366 {
3367 do_debugging = 1;
3368 dwarf_select_sections_all ();
3369 }
252b5132
RH		 3370 else
3371 {
3372 do_debugging = 0;
4cb93e3b 3373 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3374 }
3375 break;
2979dc34 3376 case OPTION_DEBUG_DUMP:
b34976b6 3377 do_dump++;
2979dc34
JJ		 3378 if (optarg == 0)
3379 do_debugging = 1;
3380 else
3381 {
2979dc34 3382 do_debugging = 0;
4cb93e3b 3383 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3384 }
3385 break;
fd2f0033
TT		 3386 case OPTION_DWARF_DEPTH:
3387 {
3388 char *cp;
3389
3390 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3391 }
3392 break;
3393 case OPTION_DWARF_START:
3394 {
3395 char *cp;
3396
3397 dwarf_start_die = strtoul (optarg, & cp, 0);
3398 }
3399 break;
2c610e4b
L		 3400 case OPTION_DYN_SYMS:
3401 do_dyn_syms++;
3402 break;
252b5132
RH		 3403#ifdef SUPPORT_DISASSEMBLY
3404 case 'i':
cf13d699
NC		 3405 request_dump (DISASS_DUMP);
3406 break;
252b5132
RH		 3407#endif
3408 case 'v':
3409 print_version (program_name);
3410 break;
3411 case 'V':
b34976b6 3412 do_version++;
252b5132 3413 break;
d974e256 3414 case 'W':
b34976b6 3415 do_wide++;
d974e256 3416 break;
252b5132 3417 default:
252b5132
RH		 3418 /* xgettext:c-format */
3419 error (_("Invalid option '-%c'\n"), c);
3420 /* Drop through. */
3421 case '?':
92f01d61 3422 usage (stderr);
252b5132
RH		 3423 }
3424 }
3425
4d6ed7c8 3426 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3427 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3428 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3429 && !do_section_groups && !do_archive_index
3430 && !do_dyn_syms)
92f01d61 3431 usage (stderr);
252b5132
RH		 3432 else if (argc < 3)
3433 {
3434 warn (_("Nothing to do.\n"));
92f01d61 3435 usage (stderr);
252b5132
RH		 3436 }
3437}
3438
3439static const char *
d3ba0551 3440get_elf_class (unsigned int elf_class)
252b5132 3441{
b34976b6 3442 static char buff[32];
103f02d3 3443
252b5132
RH		 3444 switch (elf_class)
3445 {
3446 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3447 case ELFCLASS32: return "ELF32";
3448 case ELFCLASS64: return "ELF64";
ab5e7794 3449 default:
e9e44622 3450 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3451 return buff;
252b5132
RH		 3452 }
3453}
3454
3455static const char *
d3ba0551 3456get_data_encoding (unsigned int encoding)
252b5132 3457{
b34976b6 3458 static char buff[32];
103f02d3 3459
252b5132
RH		 3460 switch (encoding)
3461 {
3462 case ELFDATANONE: return _("none");
33c63f9d
CM		 3463 case ELFDATA2LSB: return _("2's complement, little endian");
3464 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3465 default:
e9e44622 3466 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3467 return buff;
252b5132
RH		 3468 }
3469}
3470
252b5132 3471/* Decode the data held in 'elf_header'. */
ee42cf8c 3472
252b5132 3473static int
d3ba0551 3474process_file_header (void)
252b5132 3475{
b34976b6
AM		 3476 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3477 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3478 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3479 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3480 {
3481 error
3482 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3483 return 0;
3484 }
3485
2dc4cec1
L		 3486 init_dwarf_regnames (elf_header.e_machine);
3487
252b5132
RH		 3488 if (do_header)
3489 {
3490 int i;
3491
3492 printf (_("ELF Header:\n"));
3493 printf (_(" Magic: "));
b34976b6
AM		 3494 for (i = 0; i < EI_NIDENT; i++)
3495 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3496 printf ("\n");
3497 printf (_(" Class: %s\n"),
b34976b6 3498 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3499 printf (_(" Data: %s\n"),
b34976b6 3500 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3501 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3502 elf_header.e_ident[EI_VERSION],
3503 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3504 ? "(current)"
b34976b6 3505 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3506 ? _("<unknown: %lx>")
789be9f7 3507 : "")));
252b5132 3508 printf (_(" OS/ABI: %s\n"),
b34976b6 3509 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3510 printf (_(" ABI Version: %d\n"),
b34976b6 3511 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3512 printf (_(" Type: %s\n"),
3513 get_file_type (elf_header.e_type));
3514 printf (_(" Machine: %s\n"),
3515 get_machine_name (elf_header.e_machine));
3516 printf (_(" Version: 0x%lx\n"),
3517 (unsigned long) elf_header.e_version);
76da6bbe 3518
f7a99963
NC		 3519 printf (_(" Entry point address: "));
3520 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3521 printf (_("\n Start of program headers: "));
3522 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3523 printf (_(" (bytes into file)\n Start of section headers: "));
3524 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3525 printf (_(" (bytes into file)\n"));
76da6bbe 3526
252b5132
RH		 3527 printf (_(" Flags: 0x%lx%s\n"),
3528 (unsigned long) elf_header.e_flags,
3529 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3530 printf (_(" Size of this header: %ld (bytes)\n"),
3531 (long) elf_header.e_ehsize);
3532 printf (_(" Size of program headers: %ld (bytes)\n"),
3533 (long) elf_header.e_phentsize);
2046a35d 3534 printf (_(" Number of program headers: %ld"),
252b5132 3535 (long) elf_header.e_phnum);
2046a35d
AM		 3536 if (section_headers != NULL
3537 && elf_header.e_phnum == PN_XNUM
3538 && section_headers[0].sh_info != 0)
cc5914eb 3539 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3540 putc ('\n', stdout);
252b5132
RH		 3541 printf (_(" Size of section headers: %ld (bytes)\n"),
3542 (long) elf_header.e_shentsize);
560f3c1c 3543 printf (_(" Number of section headers: %ld"),
252b5132 3544 (long) elf_header.e_shnum);
4fbb74a6 3545 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3546 printf (" (%ld)", (long) section_headers[0].sh_size);
3547 putc ('\n', stdout);
3548 printf (_(" Section header string table index: %ld"),
252b5132 3549 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3550 if (section_headers != NULL
3551 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3552 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3553 else if (elf_header.e_shstrndx != SHN_UNDEF
3554 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3555 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3556 putc ('\n', stdout);
3557 }
3558
3559 if (section_headers != NULL)
3560 {
2046a35d
AM		 3561 if (elf_header.e_phnum == PN_XNUM
3562 && section_headers[0].sh_info != 0)
3563 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3564 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3565 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3566 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3567 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3568 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3569 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3570 free (section_headers);
3571 section_headers = NULL;
252b5132 3572 }
103f02d3 3573
9ea033b2
NC		 3574 return 1;
3575}
3576
252b5132 3577
9ea033b2 3578static int
91d6fa6a 3579get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3580{
2cf0635d
NC		 3581 Elf32_External_Phdr * phdrs;
3582 Elf32_External_Phdr * external;
3583 Elf_Internal_Phdr * internal;
b34976b6 3584 unsigned int i;
103f02d3 3585
3f5e193b
NC		 3586 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3587 elf_header.e_phentsize,
3588 elf_header.e_phnum,
3589 _("program headers"));
a6e9f9df
AM		 3590 if (!phdrs)
3591 return 0;
9ea033b2 3592
91d6fa6a 3593 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3594 i < elf_header.e_phnum;
b34976b6 3595 i++, internal++, external++)
252b5132 3596 {
9ea033b2
NC		 3597 internal->p_type = BYTE_GET (external->p_type);
3598 internal->p_offset = BYTE_GET (external->p_offset);
3599 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3600 internal->p_paddr = BYTE_GET (external->p_paddr);
3601 internal->p_filesz = BYTE_GET (external->p_filesz);
3602 internal->p_memsz = BYTE_GET (external->p_memsz);
3603 internal->p_flags = BYTE_GET (external->p_flags);
3604 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3605 }
3606
9ea033b2
NC		 3607 free (phdrs);
3608
252b5132
RH		 3609 return 1;
3610}
3611
9ea033b2 3612static int
91d6fa6a 3613get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3614{
2cf0635d
NC		 3615 Elf64_External_Phdr * phdrs;
3616 Elf64_External_Phdr * external;
3617 Elf_Internal_Phdr * internal;
b34976b6 3618 unsigned int i;
103f02d3 3619
3f5e193b
NC		 3620 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3621 elf_header.e_phentsize,
3622 elf_header.e_phnum,
3623 _("program headers"));
a6e9f9df
AM		 3624 if (!phdrs)
3625 return 0;
9ea033b2 3626
91d6fa6a 3627 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3628 i < elf_header.e_phnum;
b34976b6 3629 i++, internal++, external++)
9ea033b2
NC		 3630 {
3631 internal->p_type = BYTE_GET (external->p_type);
3632 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3633 internal->p_offset = BYTE_GET (external->p_offset);
3634 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3635 internal->p_paddr = BYTE_GET (external->p_paddr);
3636 internal->p_filesz = BYTE_GET (external->p_filesz);
3637 internal->p_memsz = BYTE_GET (external->p_memsz);
3638 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3639 }
3640
3641 free (phdrs);
3642
3643 return 1;
3644}
252b5132 3645
d93f0186
NC		 3646/* Returns 1 if the program headers were read into `program_headers'. */
3647
3648static int
2cf0635d 3649get_program_headers (FILE * file)
d93f0186 3650{
2cf0635d 3651 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3652
3653 /* Check cache of prior read. */
3654 if (program_headers != NULL)
3655 return 1;
3656
3f5e193b
NC		 3657 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3658 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3659
3660 if (phdrs == NULL)
3661 {
3662 error (_("Out of memory\n"));
3663 return 0;
3664 }
3665
3666 if (is_32bit_elf
3667 ? get_32bit_program_headers (file, phdrs)
3668 : get_64bit_program_headers (file, phdrs))
3669 {
3670 program_headers = phdrs;
3671 return 1;
3672 }
3673
3674 free (phdrs);
3675 return 0;
3676}
3677
2f62977e
NC		 3678/* Returns 1 if the program headers were loaded. */
3679
252b5132 3680static int
2cf0635d 3681process_program_headers (FILE * file)
252b5132 3682{
2cf0635d 3683 Elf_Internal_Phdr * segment;
b34976b6 3684 unsigned int i;
252b5132
RH		 3685
3686 if (elf_header.e_phnum == 0)
3687 {
82f2dbf7
NC		 3688 /* PR binutils/12467. */
3689 if (elf_header.e_phoff != 0)
3690 warn (_("possibly corrupt ELF header - it has a non-zero program"
3691 " header offset, but no program headers"));
3692 else if (do_segments)
252b5132 3693 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3694 return 0;
252b5132
RH		 3695 }
3696
3697 if (do_segments && !do_header)
3698 {
f7a99963
NC		 3699 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3700 printf (_("Entry point "));
3701 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3702 printf (_("\nThere are %d program headers, starting at offset "),
3703 elf_header.e_phnum);
3704 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3705 printf ("\n");
252b5132
RH		 3706 }
3707
d93f0186 3708 if (! get_program_headers (file))
252b5132 3709 return 0;
103f02d3 3710
252b5132
RH		 3711 if (do_segments)
3712 {
3a1a2036
NC		 3713 if (elf_header.e_phnum > 1)
3714 printf (_("\nProgram Headers:\n"));
3715 else
3716 printf (_("\nProgram Headers:\n"));
76da6bbe 3717
f7a99963
NC		 3718 if (is_32bit_elf)
3719 printf
3720 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3721 else if (do_wide)
3722 printf
3723 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3724 else
3725 {
3726 printf
3727 (_(" Type Offset VirtAddr PhysAddr\n"));
3728 printf
3729 (_(" FileSiz MemSiz Flags Align\n"));
3730 }
252b5132
RH		 3731 }
3732
252b5132 3733 dynamic_addr = 0;
1b228002 3734 dynamic_size = 0;
252b5132
RH		 3735
3736 for (i = 0, segment = program_headers;
3737 i < elf_header.e_phnum;
b34976b6 3738 i++, segment++)
252b5132
RH		 3739 {
3740 if (do_segments)
3741 {
103f02d3 3742 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3743
3744 if (is_32bit_elf)
3745 {
3746 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3747 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3748 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3749 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3750 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3751 printf ("%c%c%c ",
3752 (segment->p_flags & PF_R ? 'R' : ' '),
3753 (segment->p_flags & PF_W ? 'W' : ' '),
3754 (segment->p_flags & PF_X ? 'E' : ' '));
3755 printf ("%#lx", (unsigned long) segment->p_align);
3756 }
d974e256
JJ		 3757 else if (do_wide)
3758 {
3759 if ((unsigned long) segment->p_offset == segment->p_offset)
3760 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3761 else
3762 {
3763 print_vma (segment->p_offset, FULL_HEX);
3764 putchar (' ');
3765 }
3766
3767 print_vma (segment->p_vaddr, FULL_HEX);
3768 putchar (' ');
3769 print_vma (segment->p_paddr, FULL_HEX);
3770 putchar (' ');
3771
3772 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3773 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3774 else
3775 {
3776 print_vma (segment->p_filesz, FULL_HEX);
3777 putchar (' ');
3778 }
3779
3780 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3781 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3782 else
3783 {
3784 print_vma (segment->p_offset, FULL_HEX);
3785 }
3786
3787 printf (" %c%c%c ",
3788 (segment->p_flags & PF_R ? 'R' : ' '),
3789 (segment->p_flags & PF_W ? 'W' : ' '),
3790 (segment->p_flags & PF_X ? 'E' : ' '));
3791
3792 if ((unsigned long) segment->p_align == segment->p_align)
3793 printf ("%#lx", (unsigned long) segment->p_align);
3794 else
3795 {
3796 print_vma (segment->p_align, PREFIX_HEX);
3797 }
3798 }
f7a99963
NC		 3799 else
3800 {
3801 print_vma (segment->p_offset, FULL_HEX);
3802 putchar (' ');
3803 print_vma (segment->p_vaddr, FULL_HEX);
3804 putchar (' ');
3805 print_vma (segment->p_paddr, FULL_HEX);
3806 printf ("\n ");
3807 print_vma (segment->p_filesz, FULL_HEX);
3808 putchar (' ');
3809 print_vma (segment->p_memsz, FULL_HEX);
3810 printf (" %c%c%c ",
3811 (segment->p_flags & PF_R ? 'R' : ' '),
3812 (segment->p_flags & PF_W ? 'W' : ' '),
3813 (segment->p_flags & PF_X ? 'E' : ' '));
3814 print_vma (segment->p_align, HEX);
3815 }
252b5132
RH		 3816 }
3817
3818 switch (segment->p_type)
3819 {
252b5132
RH		 3820 case PT_DYNAMIC:
3821 if (dynamic_addr)
3822 error (_("more than one dynamic segment\n"));
3823
20737c13
AM		 3824 /* By default, assume that the .dynamic section is the first
3825 section in the DYNAMIC segment. */
3826 dynamic_addr = segment->p_offset;
3827 dynamic_size = segment->p_filesz;
3828
b2d38a17
NC		 3829 /* Try to locate the .dynamic section. If there is
3830 a section header table, we can easily locate it. */
3831 if (section_headers != NULL)
3832 {
2cf0635d 3833 Elf_Internal_Shdr * sec;
b2d38a17 3834
89fac5e3
RS		 3835 sec = find_section (".dynamic");
3836 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3837 {
28f997cf
TG		 3838 /* A corresponding .dynamic section is expected, but on
3839 IA-64/OpenVMS it is OK for it to be missing. */
3840 if (!is_ia64_vms ())
3841 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3842 break;
3843 }
3844
42bb2e33 3845 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3846 {
3847 dynamic_size = 0;
3848 break;
3849 }
42bb2e33 3850
b2d38a17
NC		 3851 dynamic_addr = sec->sh_offset;
3852 dynamic_size = sec->sh_size;
3853
3854 if (dynamic_addr < segment->p_offset
3855 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3856 warn (_("the .dynamic section is not contained"
3857 " within the dynamic segment\n"));
b2d38a17 3858 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3859 warn (_("the .dynamic section is not the first section"
3860 " in the dynamic segment.\n"));
b2d38a17 3861 }
252b5132
RH		 3862 break;
3863
3864 case PT_INTERP:
fb52b2f4
NC		 3865 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3866 SEEK_SET))
252b5132
RH		 3867 error (_("Unable to find program interpreter name\n"));
3868 else
3869 {
f8eae8b2
L		 3870 char fmt [32];
3871 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3872
3873 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3874 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3875
252b5132 3876 program_interpreter[0] = 0;
7bd7b3ef
AM		 3877 if (fscanf (file, fmt, program_interpreter) <= 0)
3878 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3879
3880 if (do_segments)
3881 printf (_("\n [Requesting program interpreter: %s]"),
3882 program_interpreter);
3883 }
3884 break;
3885 }
3886
3887 if (do_segments)
3888 putc ('\n', stdout);
3889 }
3890
c256ffe7 3891 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3892 {
3893 printf (_("\n Section to Segment mapping:\n"));
3894 printf (_(" Segment Sections...\n"));
3895
252b5132
RH		 3896 for (i = 0; i < elf_header.e_phnum; i++)
3897 {
9ad5cbcf 3898 unsigned int j;
2cf0635d 3899 Elf_Internal_Shdr * section;
252b5132
RH		 3900
3901 segment = program_headers + i;
b391a3e3 3902 section = section_headers + 1;
252b5132
RH		 3903
3904 printf (" %2.2d ", i);
3905
b34976b6 3906 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3907 {
f4638467
AM		 3908 if (!ELF_TBSS_SPECIAL (section, segment)
3909 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3910 printf ("%s ", SECTION_NAME (section));
3911 }
3912
3913 putc ('\n',stdout);
3914 }
3915 }
3916
252b5132
RH		 3917 return 1;
3918}
3919
3920
d93f0186
NC		 3921/* Find the file offset corresponding to VMA by using the program headers. */
3922
3923static long
2cf0635d 3924offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3925{
2cf0635d 3926 Elf_Internal_Phdr * seg;
d93f0186
NC		 3927
3928 if (! get_program_headers (file))
3929 {
3930 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3931 return (long) vma;
3932 }
3933
3934 for (seg = program_headers;
3935 seg < program_headers + elf_header.e_phnum;
3936 ++seg)
3937 {
3938 if (seg->p_type != PT_LOAD)
3939 continue;
3940
3941 if (vma >= (seg->p_vaddr & -seg->p_align)
3942 && vma + size <= seg->p_vaddr + seg->p_filesz)
3943 return vma - seg->p_vaddr + seg->p_offset;
3944 }
3945
3946 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3947 (unsigned long) vma);
d93f0186
NC		 3948 return (long) vma;
3949}
3950
3951
252b5132 3952static int
2cf0635d 3953get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3954{
2cf0635d
NC		 3955 Elf32_External_Shdr * shdrs;
3956 Elf_Internal_Shdr * internal;
b34976b6 3957 unsigned int i;
252b5132 3958
3f5e193b
NC		 3959 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3960 elf_header.e_shentsize, num,
3961 _("section headers"));
a6e9f9df
AM		 3962 if (!shdrs)
3963 return 0;
252b5132 3964
3f5e193b
NC		 3965 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3966 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3967
3968 if (section_headers == NULL)
3969 {
3970 error (_("Out of memory\n"));
3971 return 0;
3972 }
3973
3974 for (i = 0, internal = section_headers;
560f3c1c 3975 i < num;
b34976b6 3976 i++, internal++)
252b5132
RH		 3977 {
3978 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3979 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3980 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3981 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3982 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3983 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3984 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3985 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3986 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3987 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3988 }
3989
3990 free (shdrs);
3991
3992 return 1;
3993}
3994
9ea033b2 3995static int
2cf0635d 3996get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 3997{
2cf0635d
NC		 3998 Elf64_External_Shdr * shdrs;
3999 Elf_Internal_Shdr * internal;
b34976b6 4000 unsigned int i;
9ea033b2 4001
3f5e193b
NC		 4002 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4003 elf_header.e_shentsize, num,
4004 _("section headers"));
a6e9f9df
AM		 4005 if (!shdrs)
4006 return 0;
9ea033b2 4007
3f5e193b
NC		 4008 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4009 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4010
4011 if (section_headers == NULL)
4012 {
4013 error (_("Out of memory\n"));
4014 return 0;
4015 }
4016
4017 for (i = 0, internal = section_headers;
560f3c1c 4018 i < num;
b34976b6 4019 i++, internal++)
9ea033b2
NC		 4020 {
4021 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4022 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4023 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4024 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4025 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4026 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4027 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4028 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4029 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4030 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4031 }
4032
4033 free (shdrs);
4034
4035 return 1;
4036}
4037
252b5132 4038static Elf_Internal_Sym *
2cf0635d 4039get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 4040{
9ad5cbcf 4041 unsigned long number;
dd24e3da 4042 Elf32_External_Sym * esyms = NULL;
2cf0635d 4043 Elf_External_Sym_Shndx * shndx;
dd24e3da 4044 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4045 Elf_Internal_Sym * psym;
b34976b6 4046 unsigned int j;
252b5132 4047
dd24e3da
NC		 4048 /* Run some sanity checks first. */
4049 if (section->sh_entsize == 0)
4050 {
4051 error (_("sh_entsize is zero\n"));
4052 return NULL;
4053 }
4054
4055 number = section->sh_size / section->sh_entsize;
4056
4057 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4058 {
4059 error (_("Invalid sh_entsize\n"));
4060 return NULL;
4061 }
4062
3f5e193b
NC		 4063 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4064 section->sh_size, _("symbols"));
dd24e3da 4065 if (esyms == NULL)
a6e9f9df 4066 return NULL;
252b5132 4067
9ad5cbcf
AM		 4068 shndx = NULL;
4069 if (symtab_shndx_hdr != NULL
4070 && (symtab_shndx_hdr->sh_link
4fbb74a6 4071 == (unsigned long) (section - section_headers)))
9ad5cbcf 4072 {
3f5e193b
NC		 4073 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4074 symtab_shndx_hdr->sh_offset,
4075 1, symtab_shndx_hdr->sh_size,
4076 _("symtab shndx"));
dd24e3da
NC		 4077 if (shndx == NULL)
4078 goto exit_point;
9ad5cbcf
AM		 4079 }
4080
3f5e193b 4081 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4082
4083 if (isyms == NULL)
4084 {
4085 error (_("Out of memory\n"));
dd24e3da 4086 goto exit_point;
252b5132
RH		 4087 }
4088
dd24e3da 4089 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4090 {
4091 psym->st_name = BYTE_GET (esyms[j].st_name);
4092 psym->st_value = BYTE_GET (esyms[j].st_value);
4093 psym->st_size = BYTE_GET (esyms[j].st_size);
4094 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4095 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4096 psym->st_shndx
4097 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4098 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4099 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4100 psym->st_info = BYTE_GET (esyms[j].st_info);
4101 psym->st_other = BYTE_GET (esyms[j].st_other);
4102 }
4103
dd24e3da 4104 exit_point:
9ad5cbcf
AM		 4105 if (shndx)
4106 free (shndx);
dd24e3da
NC		 4107 if (esyms)
4108 free (esyms);
252b5132
RH		 4109
4110 return isyms;
4111}
4112
9ea033b2 4113static Elf_Internal_Sym *
2cf0635d 4114get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4115{
9ad5cbcf 4116 unsigned long number;
2cf0635d
NC		 4117 Elf64_External_Sym * esyms;
4118 Elf_External_Sym_Shndx * shndx;
4119 Elf_Internal_Sym * isyms;
4120 Elf_Internal_Sym * psym;
b34976b6 4121 unsigned int j;
9ea033b2 4122
dd24e3da
NC		 4123 /* Run some sanity checks first. */
4124 if (section->sh_entsize == 0)
4125 {
4126 error (_("sh_entsize is zero\n"));
4127 return NULL;
4128 }
4129
4130 number = section->sh_size / section->sh_entsize;
4131
4132 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4133 {
4134 error (_("Invalid sh_entsize\n"));
4135 return NULL;
4136 }
4137
3f5e193b
NC		 4138 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4139 section->sh_size, _("symbols"));
a6e9f9df
AM		 4140 if (!esyms)
4141 return NULL;
9ea033b2 4142
9ad5cbcf
AM		 4143 shndx = NULL;
4144 if (symtab_shndx_hdr != NULL
4145 && (symtab_shndx_hdr->sh_link
4fbb74a6 4146 == (unsigned long) (section - section_headers)))
9ad5cbcf 4147 {
3f5e193b
NC		 4148 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4149 symtab_shndx_hdr->sh_offset,
4150 1, symtab_shndx_hdr->sh_size,
4151 _("symtab shndx"));
9ad5cbcf
AM		 4152 if (!shndx)
4153 {
4154 free (esyms);
4155 return NULL;
4156 }
4157 }
4158
3f5e193b 4159 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4160
4161 if (isyms == NULL)
4162 {
4163 error (_("Out of memory\n"));
9ad5cbcf
AM		 4164 if (shndx)
4165 free (shndx);
9ea033b2 4166 free (esyms);
9ea033b2
NC		 4167 return NULL;
4168 }
4169
4170 for (j = 0, psym = isyms;
4171 j < number;
b34976b6 4172 j++, psym++)
9ea033b2
NC		 4173 {
4174 psym->st_name = BYTE_GET (esyms[j].st_name);
4175 psym->st_info = BYTE_GET (esyms[j].st_info);
4176 psym->st_other = BYTE_GET (esyms[j].st_other);
4177 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4178 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4179 psym->st_shndx
4180 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4181 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4182 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4183 psym->st_value = BYTE_GET (esyms[j].st_value);
4184 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4185 }
4186
9ad5cbcf
AM		 4187 if (shndx)
4188 free (shndx);
9ea033b2
NC		 4189 free (esyms);
4190
4191 return isyms;
4192}
4193
d1133906 4194static const char *
d3ba0551 4195get_elf_section_flags (bfd_vma sh_flags)
d1133906 4196{
5477e8a0 4197 static char buff[1024];
2cf0635d 4198 char * p = buff;
8d5ff12c 4199 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4200 int sindex;
4201 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4202 bfd_vma os_flags = 0;
4203 bfd_vma proc_flags = 0;
4204 bfd_vma unknown_flags = 0;
148b93f2 4205 static const struct
5477e8a0 4206 {
2cf0635d 4207 const char * str;
5477e8a0
L		 4208 int len;
4209 }
4210 flags [] =
4211 {
cfcac11d
NC		 4212 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4213 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4214 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4215 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4216 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4217 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4218 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4219 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4220 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4221 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4222 /* IA-64 specific. */
4223 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4224 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4225 /* IA-64 OpenVMS specific. */
4226 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4227 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4228 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4229 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4230 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4231 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4232 /* Generic. */
cfcac11d 4233 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4234 /* SPARC specific. */
cfcac11d 4235 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4236 };
4237
4238 if (do_section_details)
4239 {
8d5ff12c
L		 4240 sprintf (buff, "[%*.*lx]: ",
4241 field_size, field_size, (unsigned long) sh_flags);
4242 p += field_size + 4;
5477e8a0 4243 }
76da6bbe 4244
d1133906
NC		 4245 while (sh_flags)
4246 {
4247 bfd_vma flag;
4248
4249 flag = sh_flags & - sh_flags;
4250 sh_flags &= ~ flag;
76da6bbe 4251
5477e8a0 4252 if (do_section_details)
d1133906 4253 {
5477e8a0
L		 4254 switch (flag)
4255 {
91d6fa6a
NC		 4256 case SHF_WRITE: sindex = 0; break;
4257 case SHF_ALLOC: sindex = 1; break;
4258 case SHF_EXECINSTR: sindex = 2; break;
4259 case SHF_MERGE: sindex = 3; break;
4260 case SHF_STRINGS: sindex = 4; break;
4261 case SHF_INFO_LINK: sindex = 5; break;
4262 case SHF_LINK_ORDER: sindex = 6; break;
4263 case SHF_OS_NONCONFORMING: sindex = 7; break;
4264 case SHF_GROUP: sindex = 8; break;
4265 case SHF_TLS: sindex = 9; break;
18ae9cc1 4266 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4267
5477e8a0 4268 default:
91d6fa6a 4269 sindex = -1;
cfcac11d 4270 switch (elf_header.e_machine)
148b93f2 4271 {
cfcac11d 4272 case EM_IA_64:
148b93f2 4273 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4274 sindex = 10;
148b93f2 4275 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4276 sindex = 11;
148b93f2
NC		 4277#ifdef BFD64
4278 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4279 switch (flag)
4280 {
91d6fa6a
NC		 4281 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4282 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4283 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4284 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4285 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4286 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4287 default: break;
4288 }
4289#endif
cfcac11d
NC		 4290 break;
4291
caa83f8b
NC		 4292 case EM_386:
4293 case EM_486:
4294 case EM_X86_64:
7f502d6c 4295 case EM_L1OM:
cfcac11d
NC		 4296 case EM_OLD_SPARCV9:
4297 case EM_SPARC32PLUS:
4298 case EM_SPARCV9:
4299 case EM_SPARC:
18ae9cc1 4300 if (flag == SHF_ORDERED)
91d6fa6a 4301 sindex = 19;
cfcac11d
NC		 4302 break;
4303 default:
4304 break;
148b93f2 4305 }
5477e8a0
L		 4306 }
4307
91d6fa6a 4308 if (sindex != -1)
5477e8a0 4309 {
8d5ff12c
L		 4310 if (p != buff + field_size + 4)
4311 {
4312 if (size < (10 + 2))
4313 abort ();
4314 size -= 2;
4315 *p++ = ',';
4316 *p++ = ' ';
4317 }
4318
91d6fa6a
NC		 4319 size -= flags [sindex].len;
4320 p = stpcpy (p, flags [sindex].str);
5477e8a0 4321 }
3b22753a 4322 else if (flag & SHF_MASKOS)
8d5ff12c 4323 os_flags |= flag;
d1133906 4324 else if (flag & SHF_MASKPROC)
8d5ff12c 4325 proc_flags |= flag;
d1133906 4326 else
8d5ff12c 4327 unknown_flags |= flag;
5477e8a0
L		 4328 }
4329 else
4330 {
4331 switch (flag)
4332 {
4333 case SHF_WRITE: *p = 'W'; break;
4334 case SHF_ALLOC: *p = 'A'; break;
4335 case SHF_EXECINSTR: *p = 'X'; break;
4336 case SHF_MERGE: *p = 'M'; break;
4337 case SHF_STRINGS: *p = 'S'; break;
4338 case SHF_INFO_LINK: *p = 'I'; break;
4339 case SHF_LINK_ORDER: *p = 'L'; break;
4340 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4341 case SHF_GROUP: *p = 'G'; break;
4342 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4343 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4344
4345 default:
8a9036a4
L		 4346 if ((elf_header.e_machine == EM_X86_64
4347 || elf_header.e_machine == EM_L1OM)
5477e8a0
L		 4348 && flag == SHF_X86_64_LARGE)
4349 *p = 'l';
4350 else if (flag & SHF_MASKOS)
4351 {
4352 *p = 'o';
4353 sh_flags &= ~ SHF_MASKOS;
4354 }
4355 else if (flag & SHF_MASKPROC)
4356 {
4357 *p = 'p';
4358 sh_flags &= ~ SHF_MASKPROC;
4359 }
4360 else
4361 *p = 'x';
4362 break;
4363 }
4364 p++;
d1133906
NC		 4365 }
4366 }
76da6bbe 4367
8d5ff12c
L		 4368 if (do_section_details)
4369 {
4370 if (os_flags)
4371 {
4372 size -= 5 + field_size;
4373 if (p != buff + field_size + 4)
4374 {
4375 if (size < (2 + 1))
4376 abort ();
4377 size -= 2;
4378 *p++ = ',';
4379 *p++ = ' ';
4380 }
4381 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4382 (unsigned long) os_flags);
4383 p += 5 + field_size;
4384 }
4385 if (proc_flags)
4386 {
4387 size -= 7 + field_size;
4388 if (p != buff + field_size + 4)
4389 {
4390 if (size < (2 + 1))
4391 abort ();
4392 size -= 2;
4393 *p++ = ',';
4394 *p++ = ' ';
4395 }
4396 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4397 (unsigned long) proc_flags);
4398 p += 7 + field_size;
4399 }
4400 if (unknown_flags)
4401 {
4402 size -= 10 + field_size;
4403 if (p != buff + field_size + 4)
4404 {
4405 if (size < (2 + 1))
4406 abort ();
4407 size -= 2;
4408 *p++ = ',';
4409 *p++ = ' ';
4410 }
2b692964 4411 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4412 (unsigned long) unknown_flags);
4413 p += 10 + field_size;
4414 }
4415 }
4416
e9e44622 4417 *p = '\0';
d1133906
NC		 4418 return buff;
4419}
4420
252b5132 4421static int
2cf0635d 4422process_section_headers (FILE * file)
252b5132 4423{
2cf0635d 4424 Elf_Internal_Shdr * section;
b34976b6 4425 unsigned int i;
252b5132
RH		 4426
4427 section_headers = NULL;
4428
4429 if (elf_header.e_shnum == 0)
4430 {
82f2dbf7
NC		 4431 /* PR binutils/12467. */
4432 if (elf_header.e_shoff != 0)
4433 warn (_("possibly corrupt ELF file header - it has a non-zero"
4434 " section header offset, but no section headers\n"));
4435 else if (do_sections)
252b5132
RH		 4436 printf (_("\nThere are no sections in this file.\n"));
4437
4438 return 1;
4439 }
4440
4441 if (do_sections && !do_header)
9ea033b2 4442 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4443 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4444
9ea033b2
NC		 4445 if (is_32bit_elf)
4446 {
560f3c1c 4447 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4448 return 0;
4449 }
560f3c1c 4450 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4451 return 0;
4452
4453 /* Read in the string table, so that we have names to display. */
0b49d371 4454 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4455 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4456 {
4fbb74a6 4457 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4458
c256ffe7
JJ		 4459 if (section->sh_size != 0)
4460 {
3f5e193b
NC		 4461 string_table = (char *) get_data (NULL, file, section->sh_offset,
4462 1, section->sh_size,
4463 _("string table"));
0de14b54 4464
c256ffe7
JJ		 4465 string_table_length = string_table != NULL ? section->sh_size : 0;
4466 }
252b5132
RH		 4467 }
4468
4469 /* Scan the sections for the dynamic symbol table
e3c8793a 4470 and dynamic string table and debug sections. */
252b5132
RH		 4471 dynamic_symbols = NULL;
4472 dynamic_strings = NULL;
4473 dynamic_syminfo = NULL;
f1ef08cb 4474 symtab_shndx_hdr = NULL;
103f02d3 4475
89fac5e3
RS		 4476 eh_addr_size = is_32bit_elf ? 4 : 8;
4477 switch (elf_header.e_machine)
4478 {
4479 case EM_MIPS:
4480 case EM_MIPS_RS3_LE:
4481 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4482 FDE addresses. However, the ABI also has a semi-official ILP32
4483 variant for which the normal FDE address size rules apply.
4484
4485 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4486 section, where XX is the size of longs in bits. Unfortunately,
4487 earlier compilers provided no way of distinguishing ILP32 objects
4488 from LP64 objects, so if there's any doubt, we should assume that
4489 the official LP64 form is being used. */
4490 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4491 && find_section (".gcc_compiled_long32") == NULL)
4492 eh_addr_size = 8;
4493 break;
0f56a26a
DD		 4494
4495 case EM_H8_300:
4496 case EM_H8_300H:
4497 switch (elf_header.e_flags & EF_H8_MACH)
4498 {
4499 case E_H8_MACH_H8300:
4500 case E_H8_MACH_H8300HN:
4501 case E_H8_MACH_H8300SN:
4502 case E_H8_MACH_H8300SXN:
4503 eh_addr_size = 2;
4504 break;
4505 case E_H8_MACH_H8300H:
4506 case E_H8_MACH_H8300S:
4507 case E_H8_MACH_H8300SX:
4508 eh_addr_size = 4;
4509 break;
4510 }
f4236fe4
DD		 4511 break;
4512
ff7eeb89 4513 case EM_M32C_OLD:
f4236fe4
DD		 4514 case EM_M32C:
4515 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4516 {
4517 case EF_M32C_CPU_M16C:
4518 eh_addr_size = 2;
4519 break;
4520 }
4521 break;
89fac5e3
RS		 4522 }
4523
08d8fa11
JJ		 4524#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4525 do \
4526 { \
4527 size_t expected_entsize \
4528 = is_32bit_elf ? size32 : size64; \
4529 if (section->sh_entsize != expected_entsize) \
4530 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4531 i, (unsigned long int) section->sh_entsize, \
4532 (unsigned long int) expected_entsize); \
4533 section->sh_entsize = expected_entsize; \
4534 } \
4535 while (0)
4536#define CHECK_ENTSIZE(section, i, type) \
4537 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4538 sizeof (Elf64_External_##type))
4539
252b5132
RH		 4540 for (i = 0, section = section_headers;
4541 i < elf_header.e_shnum;
b34976b6 4542 i++, section++)
252b5132 4543 {
2cf0635d 4544 char * name = SECTION_NAME (section);
252b5132
RH		 4545
4546 if (section->sh_type == SHT_DYNSYM)
4547 {
4548 if (dynamic_symbols != NULL)
4549 {
4550 error (_("File contains multiple dynamic symbol tables\n"));
4551 continue;
4552 }
4553
08d8fa11 4554 CHECK_ENTSIZE (section, i, Sym);
19936277 4555 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4556 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4557 }
4558 else if (section->sh_type == SHT_STRTAB
18bd398b 4559 && streq (name, ".dynstr"))
252b5132
RH		 4560 {
4561 if (dynamic_strings != NULL)
4562 {
4563 error (_("File contains multiple dynamic string tables\n"));
4564 continue;
4565 }
4566
3f5e193b
NC		 4567 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4568 1, section->sh_size,
4569 _("dynamic strings"));
59245841 4570 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4571 }
9ad5cbcf
AM		 4572 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4573 {
4574 if (symtab_shndx_hdr != NULL)
4575 {
4576 error (_("File contains multiple symtab shndx tables\n"));
4577 continue;
4578 }
4579 symtab_shndx_hdr = section;
4580 }
08d8fa11
JJ		 4581 else if (section->sh_type == SHT_SYMTAB)
4582 CHECK_ENTSIZE (section, i, Sym);
4583 else if (section->sh_type == SHT_GROUP)
4584 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4585 else if (section->sh_type == SHT_REL)
4586 CHECK_ENTSIZE (section, i, Rel);
4587 else if (section->sh_type == SHT_RELA)
4588 CHECK_ENTSIZE (section, i, Rela);
252b5132 4589 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4590 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4591 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4592 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4593 && (const_strneq (name, ".debug_")
4594 || const_strneq (name, ".zdebug_")))
252b5132 4595 {
1b315056
CS		 4596 if (name[1] == 'z')
4597 name += sizeof (".zdebug_") - 1;
4598 else
4599 name += sizeof (".debug_") - 1;
252b5132
RH		 4600
4601 if (do_debugging
18bd398b 4602 || (do_debug_info && streq (name, "info"))
2b6f5997 4603 || (do_debug_info && streq (name, "types"))
18bd398b 4604 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4605 || (do_debug_lines && streq (name, "line"))
18bd398b 4606 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4607 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4608 || (do_debug_aranges && streq (name, "aranges"))
4609 || (do_debug_ranges && streq (name, "ranges"))
4610 || (do_debug_frames && streq (name, "frame"))
4611 || (do_debug_macinfo && streq (name, "macinfo"))
4612 || (do_debug_str && streq (name, "str"))
4613 || (do_debug_loc && streq (name, "loc"))
252b5132 4614 )
09c11c86 4615 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4616 }
a262ae96 4617 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4618 else if ((do_debugging || do_debug_info)
0112cd26 4619 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4620 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4621 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4622 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4623 else if (do_gdb_index && streq (name, ".gdb_index"))
4624 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4625 /* Trace sections for Itanium VMS. */
4626 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4627 || do_trace_aranges)
4628 && const_strneq (name, ".trace_"))
4629 {
4630 name += sizeof (".trace_") - 1;
4631
4632 if (do_debugging
4633 || (do_trace_info && streq (name, "info"))
4634 || (do_trace_abbrevs && streq (name, "abbrev"))
4635 || (do_trace_aranges && streq (name, "aranges"))
4636 )
4637 request_dump_bynumber (i, DEBUG_DUMP);
4638 }
4639
252b5132
RH		 4640 }
4641
4642 if (! do_sections)
4643 return 1;
4644
3a1a2036
NC		 4645 if (elf_header.e_shnum > 1)
4646 printf (_("\nSection Headers:\n"));
4647 else
4648 printf (_("\nSection Header:\n"));
76da6bbe 4649
f7a99963 4650 if (is_32bit_elf)
595cf52e 4651 {
5477e8a0 4652 if (do_section_details)
595cf52e
L		 4653 {
4654 printf (_(" [Nr] Name\n"));
5477e8a0 4655 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4656 }
4657 else
4658 printf
4659 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4660 }
d974e256 4661 else if (do_wide)
595cf52e 4662 {
5477e8a0 4663 if (do_section_details)
595cf52e
L		 4664 {
4665 printf (_(" [Nr] Name\n"));
5477e8a0 4666 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4667 }
4668 else
4669 printf
4670 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4671 }
f7a99963
NC		 4672 else
4673 {
5477e8a0 4674 if (do_section_details)
595cf52e
L		 4675 {
4676 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4677 printf (_(" Type Address Offset Link\n"));
4678 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4679 }
4680 else
4681 {
4682 printf (_(" [Nr] Name Type Address Offset\n"));
4683 printf (_(" Size EntSize Flags Link Info Align\n"));
4684 }
f7a99963 4685 }
252b5132 4686
5477e8a0
L		 4687 if (do_section_details)
4688 printf (_(" Flags\n"));
4689
252b5132
RH		 4690 for (i = 0, section = section_headers;
4691 i < elf_header.e_shnum;
b34976b6 4692 i++, section++)
252b5132 4693 {
5477e8a0 4694 if (do_section_details)
595cf52e
L		 4695 {
4696 printf (" [%2u] %s\n",
4fbb74a6 4697 i,
595cf52e
L		 4698 SECTION_NAME (section));
4699 if (is_32bit_elf || do_wide)
4700 printf (" %-15.15s ",
4701 get_section_type_name (section->sh_type));
4702 }
4703 else
b9eb56c1
NC		 4704 printf ((do_wide ? " [%2u] %-17s %-15s "
4705 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4706 i,
595cf52e
L		 4707 SECTION_NAME (section),
4708 get_section_type_name (section->sh_type));
252b5132 4709
f7a99963
NC		 4710 if (is_32bit_elf)
4711 {
cfcac11d
NC		 4712 const char * link_too_big = NULL;
4713
f7a99963 4714 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4715
f7a99963
NC		 4716 printf ( " %6.6lx %6.6lx %2.2lx",
4717 (unsigned long) section->sh_offset,
4718 (unsigned long) section->sh_size,
4719 (unsigned long) section->sh_entsize);
d1133906 4720
5477e8a0
L		 4721 if (do_section_details)
4722 fputs (" ", stdout);
4723 else
4724 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4725
cfcac11d
NC		 4726 if (section->sh_link >= elf_header.e_shnum)
4727 {
4728 link_too_big = "";
4729 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4730 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4731 switch (elf_header.e_machine)
4732 {
caa83f8b
NC		 4733 case EM_386:
4734 case EM_486:
4735 case EM_X86_64:
7f502d6c 4736 case EM_L1OM:
cfcac11d
NC		 4737 case EM_OLD_SPARCV9:
4738 case EM_SPARC32PLUS:
4739 case EM_SPARCV9:
4740 case EM_SPARC:
4741 if (section->sh_link == (SHN_BEFORE & 0xffff))
4742 link_too_big = "BEFORE";
4743 else if (section->sh_link == (SHN_AFTER & 0xffff))
4744 link_too_big = "AFTER";
4745 break;
4746 default:
4747 break;
4748 }
4749 }
4750
4751 if (do_section_details)
4752 {
4753 if (link_too_big != NULL && * link_too_big)
4754 printf ("<%s> ", link_too_big);
4755 else
4756 printf ("%2u ", section->sh_link);
4757 printf ("%3u %2lu\n", section->sh_info,
4758 (unsigned long) section->sh_addralign);
4759 }
4760 else
4761 printf ("%2u %3u %2lu\n",
4762 section->sh_link,
4763 section->sh_info,
4764 (unsigned long) section->sh_addralign);
4765
4766 if (link_too_big && ! * link_too_big)
4767 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4768 i, section->sh_link);
f7a99963 4769 }
d974e256
JJ		 4770 else if (do_wide)
4771 {
4772 print_vma (section->sh_addr, LONG_HEX);
4773
4774 if ((long) section->sh_offset == section->sh_offset)
4775 printf (" %6.6lx", (unsigned long) section->sh_offset);
4776 else
4777 {
4778 putchar (' ');
4779 print_vma (section->sh_offset, LONG_HEX);
4780 }
4781
4782 if ((unsigned long) section->sh_size == section->sh_size)
4783 printf (" %6.6lx", (unsigned long) section->sh_size);
4784 else
4785 {
4786 putchar (' ');
4787 print_vma (section->sh_size, LONG_HEX);
4788 }
4789
4790 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4791 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4792 else
4793 {
4794 putchar (' ');
4795 print_vma (section->sh_entsize, LONG_HEX);
4796 }
4797
5477e8a0
L		 4798 if (do_section_details)
4799 fputs (" ", stdout);
4800 else
4801 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4802
72de5009 4803 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4804
4805 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4806 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4807 else
4808 {
4809 print_vma (section->sh_addralign, DEC);
4810 putchar ('\n');
4811 }
4812 }
5477e8a0 4813 else if (do_section_details)
595cf52e 4814 {
5477e8a0 4815 printf (" %-15.15s ",
595cf52e 4816 get_section_type_name (section->sh_type));
595cf52e
L		 4817 print_vma (section->sh_addr, LONG_HEX);
4818 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4819 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4820 else
4821 {
4822 printf (" ");
4823 print_vma (section->sh_offset, LONG_HEX);
4824 }
72de5009 4825 printf (" %u\n ", section->sh_link);
595cf52e 4826 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4827 putchar (' ');
595cf52e
L		 4828 print_vma (section->sh_entsize, LONG_HEX);
4829
72de5009
AM		 4830 printf (" %-16u %lu\n",
4831 section->sh_info,
595cf52e
L		 4832 (unsigned long) section->sh_addralign);
4833 }
f7a99963
NC		 4834 else
4835 {
4836 putchar (' ');
4837 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4838 if ((long) section->sh_offset == section->sh_offset)
4839 printf (" %8.8lx", (unsigned long) section->sh_offset);
4840 else
4841 {
4842 printf (" ");
4843 print_vma (section->sh_offset, LONG_HEX);
4844 }
f7a99963
NC		 4845 printf ("\n ");
4846 print_vma (section->sh_size, LONG_HEX);
4847 printf (" ");
4848 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4849
d1133906 4850 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4851
72de5009
AM		 4852 printf (" %2u %3u %lu\n",
4853 section->sh_link,
4854 section->sh_info,
f7a99963
NC		 4855 (unsigned long) section->sh_addralign);
4856 }
5477e8a0
L		 4857
4858 if (do_section_details)
4859 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4860 }
4861
5477e8a0 4862 if (!do_section_details)
3dbcc61d
NC		 4863 {
4864 if (elf_header.e_machine == EM_X86_64
4865 || elf_header.e_machine == EM_L1OM)
4866 printf (_("Key to Flags:\n\
4867 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4868 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4869 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4870 else
4871 printf (_("Key to Flags:\n\
e3c8793a 4872 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4873 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4874 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4875 }
d1133906 4876
252b5132
RH		 4877 return 1;
4878}
4879
f5842774
L		 4880static const char *
4881get_group_flags (unsigned int flags)
4882{
4883 static char buff[32];
4884 switch (flags)
4885 {
220453ec
AM		 4886 case 0:
4887 return "";
4888
f5842774 4889 case GRP_COMDAT:
220453ec 4890 return "COMDAT ";
f5842774
L		 4891
4892 default:
220453ec 4893 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4894 break;
4895 }
4896 return buff;
4897}
4898
4899static int
2cf0635d 4900process_section_groups (FILE * file)
f5842774 4901{
2cf0635d 4902 Elf_Internal_Shdr * section;
f5842774 4903 unsigned int i;
2cf0635d
NC		 4904 struct group * group;
4905 Elf_Internal_Shdr * symtab_sec;
4906 Elf_Internal_Shdr * strtab_sec;
4907 Elf_Internal_Sym * symtab;
4908 char * strtab;
c256ffe7 4909 size_t strtab_size;
d1f5c6e3
L		 4910
4911 /* Don't process section groups unless needed. */
4912 if (!do_unwind && !do_section_groups)
4913 return 1;
f5842774
L		 4914
4915 if (elf_header.e_shnum == 0)
4916 {
4917 if (do_section_groups)
82f2dbf7 4918 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4919
4920 return 1;
4921 }
4922
4923 if (section_headers == NULL)
4924 {
4925 error (_("Section headers are not available!\n"));
4926 abort ();
4927 }
4928
3f5e193b
NC		 4929 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4930 sizeof (struct group *));
e4b17d5c
L		 4931
4932 if (section_headers_groups == NULL)
4933 {
4934 error (_("Out of memory\n"));
4935 return 0;
4936 }
4937
f5842774 4938 /* Scan the sections for the group section. */
d1f5c6e3 4939 group_count = 0;
f5842774
L		 4940 for (i = 0, section = section_headers;
4941 i < elf_header.e_shnum;
4942 i++, section++)
e4b17d5c
L		 4943 if (section->sh_type == SHT_GROUP)
4944 group_count++;
4945
d1f5c6e3
L		 4946 if (group_count == 0)
4947 {
4948 if (do_section_groups)
4949 printf (_("\nThere are no section groups in this file.\n"));
4950
4951 return 1;
4952 }
4953
3f5e193b 4954 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4955
4956 if (section_groups == NULL)
4957 {
4958 error (_("Out of memory\n"));
4959 return 0;
4960 }
4961
d1f5c6e3
L		 4962 symtab_sec = NULL;
4963 strtab_sec = NULL;
4964 symtab = NULL;
4965 strtab = NULL;
c256ffe7 4966 strtab_size = 0;
e4b17d5c
L		 4967 for (i = 0, section = section_headers, group = section_groups;
4968 i < elf_header.e_shnum;
4969 i++, section++)
f5842774
L		 4970 {
4971 if (section->sh_type == SHT_GROUP)
4972 {
2cf0635d
NC		 4973 char * name = SECTION_NAME (section);
4974 char * group_name;
4975 unsigned char * start;
4976 unsigned char * indices;
f5842774 4977 unsigned int entry, j, size;
2cf0635d
NC		 4978 Elf_Internal_Shdr * sec;
4979 Elf_Internal_Sym * sym;
f5842774
L		 4980
4981 /* Get the symbol table. */
4fbb74a6
AM		 4982 if (section->sh_link >= elf_header.e_shnum
4983 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4984 != SHT_SYMTAB))
f5842774
L		 4985 {
4986 error (_("Bad sh_link in group section `%s'\n"), name);
4987 continue;
4988 }
d1f5c6e3
L		 4989
4990 if (symtab_sec != sec)
4991 {
4992 symtab_sec = sec;
4993 if (symtab)
4994 free (symtab);
4995 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4996 }
f5842774 4997
dd24e3da
NC		 4998 if (symtab == NULL)
4999 {
5000 error (_("Corrupt header in group section `%s'\n"), name);
5001 continue;
5002 }
5003
f5842774
L		 5004 sym = symtab + section->sh_info;
5005
5006 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5007 {
4fbb74a6
AM		 5008 if (sym->st_shndx == 0
5009 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5010 {
5011 error (_("Bad sh_info in group section `%s'\n"), name);
5012 continue;
5013 }
ba2685cc 5014
4fbb74a6 5015 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5016 strtab_sec = NULL;
5017 if (strtab)
5018 free (strtab);
f5842774 5019 strtab = NULL;
c256ffe7 5020 strtab_size = 0;
f5842774
L		 5021 }
5022 else
5023 {
5024 /* Get the string table. */
4fbb74a6 5025 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5026 {
5027 strtab_sec = NULL;
5028 if (strtab)
5029 free (strtab);
5030 strtab = NULL;
5031 strtab_size = 0;
5032 }
5033 else if (strtab_sec
4fbb74a6 5034 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5035 {
5036 strtab_sec = sec;
5037 if (strtab)
5038 free (strtab);
3f5e193b
NC		 5039 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5040 1, strtab_sec->sh_size,
5041 _("string table"));
c256ffe7 5042 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5043 }
c256ffe7 5044 group_name = sym->st_name < strtab_size
2b692964 5045 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5046 }
5047
3f5e193b
NC		 5048 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5049 1, section->sh_size,
5050 _("section data"));
59245841
NC		 5051 if (start == NULL)
5052 continue;
f5842774
L		 5053
5054 indices = start;
5055 size = (section->sh_size / section->sh_entsize) - 1;
5056 entry = byte_get (indices, 4);
5057 indices += 4;
e4b17d5c
L		 5058
5059 if (do_section_groups)
5060 {
2b692964 5061 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5062 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5063
e4b17d5c
L		 5064 printf (_(" [Index] Name\n"));
5065 }
5066
5067 group->group_index = i;
5068
f5842774
L		 5069 for (j = 0; j < size; j++)
5070 {
2cf0635d 5071 struct group_list * g;
e4b17d5c 5072
f5842774
L		 5073 entry = byte_get (indices, 4);
5074 indices += 4;
5075
4fbb74a6 5076 if (entry >= elf_header.e_shnum)
391cb864
L		 5077 {
5078 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5079 entry, i, elf_header.e_shnum - 1);
5080 continue;
5081 }
391cb864 5082
4fbb74a6 5083 if (section_headers_groups [entry] != NULL)
e4b17d5c 5084 {
d1f5c6e3
L		 5085 if (entry)
5086 {
391cb864
L		 5087 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5088 entry, i,
4fbb74a6 5089 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5090 continue;
5091 }
5092 else
5093 {
5094 /* Intel C/C++ compiler may put section 0 in a
5095 section group. We just warn it the first time
5096 and ignore it afterwards. */
5097 static int warned = 0;
5098 if (!warned)
5099 {
5100 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5101 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5102 warned++;
5103 }
5104 }
e4b17d5c
L		 5105 }
5106
4fbb74a6 5107 section_headers_groups [entry] = group;
e4b17d5c
L		 5108
5109 if (do_section_groups)
5110 {
4fbb74a6 5111 sec = section_headers + entry;
c256ffe7 5112 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5113 }
5114
3f5e193b 5115 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5116 g->section_index = entry;
5117 g->next = group->root;
5118 group->root = g;
f5842774
L		 5119 }
5120
f5842774
L		 5121 if (start)
5122 free (start);
e4b17d5c
L		 5123
5124 group++;
f5842774
L		 5125 }
5126 }
5127
d1f5c6e3
L		 5128 if (symtab)
5129 free (symtab);
5130 if (strtab)
5131 free (strtab);
f5842774
L		 5132 return 1;
5133}
5134
28f997cf
TG		 5135/* Data used to display dynamic fixups. */
5136
5137struct ia64_vms_dynfixup
5138{
5139 bfd_vma needed_ident; /* Library ident number. */
5140 bfd_vma needed; /* Index in the dstrtab of the library name. */
5141 bfd_vma fixup_needed; /* Index of the library. */
5142 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5143 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5144};
5145
5146/* Data used to display dynamic relocations. */
5147
5148struct ia64_vms_dynimgrela
5149{
5150 bfd_vma img_rela_cnt; /* Number of relocations. */
5151 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5152};
5153
5154/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5155 library). */
5156
5157static void
5158dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5159 const char *strtab, unsigned int strtab_sz)
5160{
5161 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5162 long i;
5163 const char *lib_name;
5164
5165 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5166 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5167 _("dynamic section image fixups"));
5168 if (!imfs)
5169 return;
5170
5171 if (fixup->needed < strtab_sz)
5172 lib_name = strtab + fixup->needed;
5173 else
5174 {
5175 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5176 (unsigned long) fixup->needed);
28f997cf
TG		 5177 lib_name = "???";
5178 }
5179 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5180 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5181 printf
5182 (_("Seg Offset Type SymVec DataType\n"));
5183
5184 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5185 {
5186 unsigned int type;
5187 const char *rtype;
5188
5189 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5190 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5191 type = BYTE_GET (imfs [i].type);
5192 rtype = elf_ia64_reloc_type (type);
5193 if (rtype == NULL)
5194 printf (" 0x%08x ", type);
5195 else
5196 printf (" %-32s ", rtype);
5197 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5198 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5199 }
5200
5201 free (imfs);
5202}
5203
5204/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5205
5206static void
5207dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5208{
5209 Elf64_External_VMS_IMAGE_RELA *imrs;
5210 long i;
5211
5212 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5213 1, imgrela->img_rela_cnt * sizeof (*imrs),
5214 _("dynamic section image relas"));
5215 if (!imrs)
5216 return;
5217
5218 printf (_("\nImage relocs\n"));
5219 printf
5220 (_("Seg Offset Type Addend Seg Sym Off\n"));
5221
5222 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5223 {
5224 unsigned int type;
5225 const char *rtype;
5226
5227 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5228 printf ("%08" BFD_VMA_FMT "x ",
5229 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5230 type = BYTE_GET (imrs [i].type);
5231 rtype = elf_ia64_reloc_type (type);
5232 if (rtype == NULL)
5233 printf ("0x%08x ", type);
5234 else
5235 printf ("%-31s ", rtype);
5236 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5237 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5238 printf ("%08" BFD_VMA_FMT "x\n",
5239 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5240 }
5241
5242 free (imrs);
5243}
5244
5245/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5246
5247static int
5248process_ia64_vms_dynamic_relocs (FILE *file)
5249{
5250 struct ia64_vms_dynfixup fixup;
5251 struct ia64_vms_dynimgrela imgrela;
5252 Elf_Internal_Dyn *entry;
5253 int res = 0;
5254 bfd_vma strtab_off = 0;
5255 bfd_vma strtab_sz = 0;
5256 char *strtab = NULL;
5257
5258 memset (&fixup, 0, sizeof (fixup));
5259 memset (&imgrela, 0, sizeof (imgrela));
5260
5261 /* Note: the order of the entries is specified by the OpenVMS specs. */
5262 for (entry = dynamic_section;
5263 entry < dynamic_section + dynamic_nent;
5264 entry++)
5265 {
5266 switch (entry->d_tag)
5267 {
5268 case DT_IA_64_VMS_STRTAB_OFFSET:
5269 strtab_off = entry->d_un.d_val;
5270 break;
5271 case DT_STRSZ:
5272 strtab_sz = entry->d_un.d_val;
5273 if (strtab == NULL)
5274 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5275 1, strtab_sz, _("dynamic string section"));
5276 break;
5277
5278 case DT_IA_64_VMS_NEEDED_IDENT:
5279 fixup.needed_ident = entry->d_un.d_val;
5280 break;
5281 case DT_NEEDED:
5282 fixup.needed = entry->d_un.d_val;
5283 break;
5284 case DT_IA_64_VMS_FIXUP_NEEDED:
5285 fixup.fixup_needed = entry->d_un.d_val;
5286 break;
5287 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5288 fixup.fixup_rela_cnt = entry->d_un.d_val;
5289 break;
5290 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5291 fixup.fixup_rela_off = entry->d_un.d_val;
5292 res++;
5293 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5294 break;
5295
5296 case DT_IA_64_VMS_IMG_RELA_CNT:
5297 imgrela.img_rela_cnt = entry->d_un.d_val;
5298 break;
5299 case DT_IA_64_VMS_IMG_RELA_OFF:
5300 imgrela.img_rela_off = entry->d_un.d_val;
5301 res++;
5302 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5303 break;
5304
5305 default:
5306 break;
5307 }
5308 }
5309
5310 if (strtab != NULL)
5311 free (strtab);
5312
5313 return res;
5314}
5315
85b1c36d 5316static struct
566b0d53 5317{
2cf0635d 5318 const char * name;
566b0d53
L		 5319 int reloc;
5320 int size;
5321 int rela;
5322} dynamic_relocations [] =
5323{
5324 { "REL", DT_REL, DT_RELSZ, FALSE },
5325 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5326 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5327};
5328
252b5132 5329/* Process the reloc section. */
18bd398b 5330
252b5132 5331static int
2cf0635d 5332process_relocs (FILE * file)
252b5132 5333{
b34976b6
AM		 5334 unsigned long rel_size;
5335 unsigned long rel_offset;
252b5132
RH		 5336
5337
5338 if (!do_reloc)
5339 return 1;
5340
5341 if (do_using_dynamic)
5342 {
566b0d53 5343 int is_rela;
2cf0635d 5344 const char * name;
566b0d53
L		 5345 int has_dynamic_reloc;
5346 unsigned int i;
0de14b54 5347
566b0d53 5348 has_dynamic_reloc = 0;
252b5132 5349
566b0d53 5350 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5351 {
566b0d53
L		 5352 is_rela = dynamic_relocations [i].rela;
5353 name = dynamic_relocations [i].name;
5354 rel_size = dynamic_info [dynamic_relocations [i].size];
5355 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5356
566b0d53
L		 5357 has_dynamic_reloc |= rel_size;
5358
5359 if (is_rela == UNKNOWN)
aa903cfb 5360 {
566b0d53
L		 5361 if (dynamic_relocations [i].reloc == DT_JMPREL)
5362 switch (dynamic_info[DT_PLTREL])
5363 {
5364 case DT_REL:
5365 is_rela = FALSE;
5366 break;
5367 case DT_RELA:
5368 is_rela = TRUE;
5369 break;
5370 }
aa903cfb 5371 }
252b5132 5372
566b0d53
L		 5373 if (rel_size)
5374 {
5375 printf
5376 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5377 name, rel_offset, rel_size);
252b5132 5378
d93f0186
NC		 5379 dump_relocations (file,
5380 offset_from_vma (file, rel_offset, rel_size),
5381 rel_size,
566b0d53 5382 dynamic_symbols, num_dynamic_syms,
d79b3d50 5383 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5384 }
252b5132 5385 }
566b0d53 5386
28f997cf
TG		 5387 if (is_ia64_vms ())
5388 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5389
566b0d53 5390 if (! has_dynamic_reloc)
252b5132
RH		 5391 printf (_("\nThere are no dynamic relocations in this file.\n"));
5392 }
5393 else
5394 {
2cf0635d 5395 Elf_Internal_Shdr * section;
b34976b6
AM		 5396 unsigned long i;
5397 int found = 0;
252b5132
RH		 5398
5399 for (i = 0, section = section_headers;
5400 i < elf_header.e_shnum;
b34976b6 5401 i++, section++)
252b5132
RH		 5402 {
5403 if ( section->sh_type != SHT_RELA
5404 && section->sh_type != SHT_REL)
5405 continue;
5406
5407 rel_offset = section->sh_offset;
5408 rel_size = section->sh_size;
5409
5410 if (rel_size)
5411 {
2cf0635d 5412 Elf_Internal_Shdr * strsec;
b34976b6 5413 int is_rela;
103f02d3 5414
252b5132
RH		 5415 printf (_("\nRelocation section "));
5416
5417 if (string_table == NULL)
19936277 5418 printf ("%d", section->sh_name);
252b5132 5419 else
3a1a2036 5420 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5421
5422 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5423 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5424
d79b3d50
NC		 5425 is_rela = section->sh_type == SHT_RELA;
5426
4fbb74a6
AM		 5427 if (section->sh_link != 0
5428 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5429 {
2cf0635d
NC		 5430 Elf_Internal_Shdr * symsec;
5431 Elf_Internal_Sym * symtab;
d79b3d50 5432 unsigned long nsyms;
c256ffe7 5433 unsigned long strtablen = 0;
2cf0635d 5434 char * strtab = NULL;
57346661 5435
4fbb74a6 5436 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5437 if (symsec->sh_type != SHT_SYMTAB
5438 && symsec->sh_type != SHT_DYNSYM)
5439 continue;
5440
af3fc3bc 5441 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5442 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5443
af3fc3bc
AM		 5444 if (symtab == NULL)
5445 continue;
252b5132 5446
4fbb74a6
AM		 5447 if (symsec->sh_link != 0
5448 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5449 {
4fbb74a6 5450 strsec = section_headers + symsec->sh_link;
103f02d3 5451
3f5e193b
NC		 5452 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5453 1, strsec->sh_size,
5454 _("string table"));
c256ffe7
JJ		 5455 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5456 }
252b5132 5457
d79b3d50
NC		 5458 dump_relocations (file, rel_offset, rel_size,
5459 symtab, nsyms, strtab, strtablen, is_rela);
5460 if (strtab)
5461 free (strtab);
5462 free (symtab);
5463 }
5464 else
5465 dump_relocations (file, rel_offset, rel_size,
5466 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5467
5468 found = 1;
5469 }
5470 }
5471
5472 if (! found)
5473 printf (_("\nThere are no relocations in this file.\n"));
5474 }
5475
5476 return 1;
5477}
5478
57346661
AM		 5479/* Process the unwind section. */
5480
4d6ed7c8
NC		 5481#include "unwind-ia64.h"
5482
5483/* An absolute address consists of a section and an offset. If the
5484 section is NULL, the offset itself is the address, otherwise, the
5485 address equals to LOAD_ADDRESS(section) + offset. */
5486
5487struct absaddr
5488 {
5489 unsigned short section;
5490 bfd_vma offset;
5491 };
5492
1949de15
L		 5493#define ABSADDR(a) \
5494 ((a).section \
5495 ? section_headers [(a).section].sh_addr + (a).offset \
5496 : (a).offset)
5497
3f5e193b
NC		 5498struct ia64_unw_table_entry
5499 {
5500 struct absaddr start;
5501 struct absaddr end;
5502 struct absaddr info;
5503 };
5504
57346661 5505struct ia64_unw_aux_info
4d6ed7c8 5506 {
3f5e193b
NC		 5507
5508 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5509 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5510 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5511 unsigned long info_size; /* Size of unwind info. */
5512 bfd_vma info_addr; /* starting address of unwind info. */
5513 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5514 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5515 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5516 char * strtab; /* The string table. */
b34976b6 5517 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5518 };
5519
4d6ed7c8 5520static void
2cf0635d 5521find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5522 unsigned long nsyms,
2cf0635d 5523 const char * strtab,
57346661 5524 unsigned long strtab_size,
d3ba0551 5525 struct absaddr addr,
2cf0635d
NC		 5526 const char ** symname,
5527 bfd_vma * offset)
4d6ed7c8 5528{
d3ba0551 5529 bfd_vma dist = 0x100000;
2cf0635d
NC		 5530 Elf_Internal_Sym * sym;
5531 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5532 unsigned long i;
5533
0b6ae522
DJ		 5534 REMOVE_ARCH_BITS (addr.offset);
5535
57346661 5536 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5537 {
0b6ae522
DJ		 5538 bfd_vma value = sym->st_value;
5539
5540 REMOVE_ARCH_BITS (value);
5541
4d6ed7c8
NC		 5542 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5543 && sym->st_name != 0
5544 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5545 && addr.offset >= value
5546 && addr.offset - value < dist)
4d6ed7c8
NC		 5547 {
5548 best = sym;
0b6ae522 5549 dist = addr.offset - value;
4d6ed7c8
NC		 5550 if (!dist)
5551 break;
5552 }
5553 }
5554 if (best)
5555 {
57346661 5556 *symname = (best->st_name >= strtab_size
2b692964 5557 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5558 *offset = dist;
5559 return;
5560 }
5561 *symname = NULL;
5562 *offset = addr.offset;
5563}
5564
5565static void
2cf0635d 5566dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5567{
2cf0635d 5568 struct ia64_unw_table_entry * tp;
4d6ed7c8 5569 int in_body;
7036c0e1 5570
4d6ed7c8
NC		 5571 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5572 {
5573 bfd_vma stamp;
5574 bfd_vma offset;
2cf0635d
NC		 5575 const unsigned char * dp;
5576 const unsigned char * head;
5577 const char * procname;
4d6ed7c8 5578
57346661
AM		 5579 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5580 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5581
5582 fputs ("\n<", stdout);
5583
5584 if (procname)
5585 {
5586 fputs (procname, stdout);
5587
5588 if (offset)
5589 printf ("+%lx", (unsigned long) offset);
5590 }
5591
5592 fputs (">: [", stdout);
5593 print_vma (tp->start.offset, PREFIX_HEX);
5594 fputc ('-', stdout);
5595 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5596 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5597 (unsigned long) (tp->info.offset - aux->seg_base));
5598
1949de15 5599 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5600 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5601
86f55779 5602 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5603 (unsigned) UNW_VER (stamp),
5604 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5605 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5606 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5607 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5608
5609 if (UNW_VER (stamp) != 1)
5610 {
2b692964 5611 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5612 continue;
5613 }
5614
5615 in_body = 0;
89fac5e3 5616 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5617 dp = unw_decode (dp, in_body, & in_body);
5618 }
5619}
5620
5621static int
2cf0635d
NC		 5622slurp_ia64_unwind_table (FILE * file,
5623 struct ia64_unw_aux_info * aux,
5624 Elf_Internal_Shdr * sec)
4d6ed7c8 5625{
89fac5e3 5626 unsigned long size, nrelas, i;
2cf0635d
NC		 5627 Elf_Internal_Phdr * seg;
5628 struct ia64_unw_table_entry * tep;
5629 Elf_Internal_Shdr * relsec;
5630 Elf_Internal_Rela * rela;
5631 Elf_Internal_Rela * rp;
5632 unsigned char * table;
5633 unsigned char * tp;
5634 Elf_Internal_Sym * sym;
5635 const char * relname;
4d6ed7c8 5636
4d6ed7c8
NC		 5637 /* First, find the starting address of the segment that includes
5638 this section: */
5639
5640 if (elf_header.e_phnum)
5641 {
d93f0186 5642 if (! get_program_headers (file))
4d6ed7c8 5643 return 0;
4d6ed7c8 5644
d93f0186
NC		 5645 for (seg = program_headers;
5646 seg < program_headers + elf_header.e_phnum;
5647 ++seg)
4d6ed7c8
NC		 5648 {
5649 if (seg->p_type != PT_LOAD)
5650 continue;
5651
5652 if (sec->sh_addr >= seg->p_vaddr
5653 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5654 {
5655 aux->seg_base = seg->p_vaddr;
5656 break;
5657 }
5658 }
4d6ed7c8
NC		 5659 }
5660
5661 /* Second, build the unwind table from the contents of the unwind section: */
5662 size = sec->sh_size;
3f5e193b
NC		 5663 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5664 _("unwind table"));
a6e9f9df
AM		 5665 if (!table)
5666 return 0;
4d6ed7c8 5667
3f5e193b
NC		 5668 aux->table = (struct ia64_unw_table_entry *)
5669 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5670 tep = aux->table;
c6a0c689 5671 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5672 {
5673 tep->start.section = SHN_UNDEF;
5674 tep->end.section = SHN_UNDEF;
5675 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5676 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5677 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5678 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5679 tep->start.offset += aux->seg_base;
5680 tep->end.offset += aux->seg_base;
5681 tep->info.offset += aux->seg_base;
5682 }
5683 free (table);
5684
41e92641 5685 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5686 for (relsec = section_headers;
5687 relsec < section_headers + elf_header.e_shnum;
5688 ++relsec)
5689 {
5690 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5691 || relsec->sh_info >= elf_header.e_shnum
5692 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5693 continue;
5694
5695 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5696 & rela, & nrelas))
5697 return 0;
5698
5699 for (rp = rela; rp < rela + nrelas; ++rp)
5700 {
aca88567
NC		 5701 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5702 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5703
0112cd26 5704 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5705 {
e5fb9629 5706 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5707 continue;
5708 }
5709
89fac5e3 5710 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5711
89fac5e3 5712 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5713 {
5714 case 0:
5715 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5716 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5717 break;
5718 case 1:
5719 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5720 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5721 break;
5722 case 2:
5723 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5724 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5725 break;
5726 default:
5727 break;
5728 }
5729 }
5730
5731 free (rela);
5732 }
5733
89fac5e3 5734 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5735 return 1;
5736}
5737
5738static int
2cf0635d 5739ia64_process_unwind (FILE * file)
4d6ed7c8 5740{
2cf0635d
NC		 5741 Elf_Internal_Shdr * sec;
5742 Elf_Internal_Shdr * unwsec = NULL;
5743 Elf_Internal_Shdr * strsec;
89fac5e3 5744 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5745 struct ia64_unw_aux_info aux;
f1467e33 5746
4d6ed7c8
NC		 5747 memset (& aux, 0, sizeof (aux));
5748
4d6ed7c8
NC		 5749 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5750 {
c256ffe7 5751 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5752 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5753 {
5754 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5755 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5756
4fbb74a6 5757 strsec = section_headers + sec->sh_link;
59245841 5758 assert (aux.strtab == NULL);
3f5e193b
NC		 5759 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5760 1, strsec->sh_size,
5761 _("string table"));
c256ffe7 5762 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5763 }
5764 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5765 unwcount++;
5766 }
5767
5768 if (!unwcount)
5769 printf (_("\nThere are no unwind sections in this file.\n"));
5770
5771 while (unwcount-- > 0)
5772 {
2cf0635d 5773 char * suffix;
579f31ac
JJ		 5774 size_t len, len2;
5775
5776 for (i = unwstart, sec = section_headers + unwstart;
5777 i < elf_header.e_shnum; ++i, ++sec)
5778 if (sec->sh_type == SHT_IA_64_UNWIND)
5779 {
5780 unwsec = sec;
5781 break;
5782 }
5783
5784 unwstart = i + 1;
5785 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5786
e4b17d5c
L		 5787 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5788 {
5789 /* We need to find which section group it is in. */
2cf0635d 5790 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5791
5792 for (; g != NULL; g = g->next)
5793 {
4fbb74a6 5794 sec = section_headers + g->section_index;
18bd398b
NC		 5795
5796 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5797 break;
e4b17d5c
L		 5798 }
5799
5800 if (g == NULL)
5801 i = elf_header.e_shnum;
5802 }
18bd398b 5803 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5804 {
18bd398b 5805 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5806 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5807 suffix = SECTION_NAME (unwsec) + len;
5808 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5809 ++i, ++sec)
18bd398b
NC		 5810 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5811 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5812 break;
5813 }
5814 else
5815 {
5816 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5817 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5818 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5819 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5820 suffix = "";
18bd398b 5821 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5822 suffix = SECTION_NAME (unwsec) + len;
5823 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5824 ++i, ++sec)
18bd398b
NC		 5825 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5826 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5827 break;
5828 }
5829
5830 if (i == elf_header.e_shnum)
5831 {
5832 printf (_("\nCould not find unwind info section for "));
5833
5834 if (string_table == NULL)
5835 printf ("%d", unwsec->sh_name);
5836 else
3a1a2036 5837 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5838 }
5839 else
4d6ed7c8 5840 {
4d6ed7c8 5841 aux.info_addr = sec->sh_addr;
3f5e193b 5842 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5843 sec->sh_size,
3f5e193b 5844 _("unwind info"));
59245841 5845 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5846
579f31ac 5847 printf (_("\nUnwind section "));
4d6ed7c8 5848
579f31ac
JJ		 5849 if (string_table == NULL)
5850 printf ("%d", unwsec->sh_name);
5851 else
3a1a2036 5852 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5853
579f31ac 5854 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5855 (unsigned long) unwsec->sh_offset,
89fac5e3 5856 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5857
579f31ac 5858 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5859
579f31ac
JJ		 5860 if (aux.table_len > 0)
5861 dump_ia64_unwind (& aux);
5862
5863 if (aux.table)
5864 free ((char *) aux.table);
5865 if (aux.info)
5866 free ((char *) aux.info);
5867 aux.table = NULL;
5868 aux.info = NULL;
5869 }
4d6ed7c8 5870 }
4d6ed7c8 5871
4d6ed7c8
NC		 5872 if (aux.symtab)
5873 free (aux.symtab);
5874 if (aux.strtab)
5875 free ((char *) aux.strtab);
5876
5877 return 1;
5878}
5879
3f5e193b
NC		 5880struct hppa_unw_table_entry
5881 {
5882 struct absaddr start;
5883 struct absaddr end;
5884 unsigned int Cannot_unwind:1; /* 0 */
5885 unsigned int Millicode:1; /* 1 */
5886 unsigned int Millicode_save_sr0:1; /* 2 */
5887 unsigned int Region_description:2; /* 3..4 */
5888 unsigned int reserved1:1; /* 5 */
5889 unsigned int Entry_SR:1; /* 6 */
5890 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5891 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5892 unsigned int Args_stored:1; /* 16 */
5893 unsigned int Variable_Frame:1; /* 17 */
5894 unsigned int Separate_Package_Body:1; /* 18 */
5895 unsigned int Frame_Extension_Millicode:1; /* 19 */
5896 unsigned int Stack_Overflow_Check:1; /* 20 */
5897 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5898 unsigned int Ada_Region:1; /* 22 */
5899 unsigned int cxx_info:1; /* 23 */
5900 unsigned int cxx_try_catch:1; /* 24 */
5901 unsigned int sched_entry_seq:1; /* 25 */
5902 unsigned int reserved2:1; /* 26 */
5903 unsigned int Save_SP:1; /* 27 */
5904 unsigned int Save_RP:1; /* 28 */
5905 unsigned int Save_MRP_in_frame:1; /* 29 */
5906 unsigned int extn_ptr_defined:1; /* 30 */
5907 unsigned int Cleanup_defined:1; /* 31 */
5908
5909 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5910 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5911 unsigned int Large_frame:1; /* 2 */
5912 unsigned int Pseudo_SP_Set:1; /* 3 */
5913 unsigned int reserved4:1; /* 4 */
5914 unsigned int Total_frame_size:27; /* 5..31 */
5915 };
5916
57346661
AM		 5917struct hppa_unw_aux_info
5918 {
3f5e193b 5919 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5920 unsigned long table_len; /* Length of unwind table. */
5921 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5922 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5923 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5924 char * strtab; /* The string table. */
57346661
AM		 5925 unsigned long strtab_size; /* Size of string table. */
5926 };
5927
5928static void
2cf0635d 5929dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5930{
2cf0635d 5931 struct hppa_unw_table_entry * tp;
57346661 5932
57346661
AM		 5933 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5934 {
5935 bfd_vma offset;
2cf0635d 5936 const char * procname;
57346661
AM		 5937
5938 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5939 aux->strtab_size, tp->start, &procname,
5940 &offset);
5941
5942 fputs ("\n<", stdout);
5943
5944 if (procname)
5945 {
5946 fputs (procname, stdout);
5947
5948 if (offset)
5949 printf ("+%lx", (unsigned long) offset);
5950 }
5951
5952 fputs (">: [", stdout);
5953 print_vma (tp->start.offset, PREFIX_HEX);
5954 fputc ('-', stdout);
5955 print_vma (tp->end.offset, PREFIX_HEX);
5956 printf ("]\n\t");
5957
18bd398b
NC		 5958#define PF(_m) if (tp->_m) printf (#_m " ");
5959#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5960 PF(Cannot_unwind);
5961 PF(Millicode);
5962 PF(Millicode_save_sr0);
18bd398b 5963 /* PV(Region_description); */
57346661
AM		 5964 PF(Entry_SR);
5965 PV(Entry_FR);
5966 PV(Entry_GR);
5967 PF(Args_stored);
5968 PF(Variable_Frame);
5969 PF(Separate_Package_Body);
5970 PF(Frame_Extension_Millicode);
5971 PF(Stack_Overflow_Check);
5972 PF(Two_Instruction_SP_Increment);
5973 PF(Ada_Region);
5974 PF(cxx_info);
5975 PF(cxx_try_catch);
5976 PF(sched_entry_seq);
5977 PF(Save_SP);
5978 PF(Save_RP);
5979 PF(Save_MRP_in_frame);
5980 PF(extn_ptr_defined);
5981 PF(Cleanup_defined);
5982 PF(MPE_XL_interrupt_marker);
5983 PF(HP_UX_interrupt_marker);
5984 PF(Large_frame);
5985 PF(Pseudo_SP_Set);
5986 PV(Total_frame_size);
5987#undef PF
5988#undef PV
5989 }
5990
18bd398b 5991 printf ("\n");
57346661
AM		 5992}
5993
5994static int
2cf0635d
NC		 5995slurp_hppa_unwind_table (FILE * file,
5996 struct hppa_unw_aux_info * aux,
5997 Elf_Internal_Shdr * sec)
57346661 5998{
1c0751b2 5999 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6000 Elf_Internal_Phdr * seg;
6001 struct hppa_unw_table_entry * tep;
6002 Elf_Internal_Shdr * relsec;
6003 Elf_Internal_Rela * rela;
6004 Elf_Internal_Rela * rp;
6005 unsigned char * table;
6006 unsigned char * tp;
6007 Elf_Internal_Sym * sym;
6008 const char * relname;
57346661 6009
57346661
AM		 6010 /* First, find the starting address of the segment that includes
6011 this section. */
6012
6013 if (elf_header.e_phnum)
6014 {
6015 if (! get_program_headers (file))
6016 return 0;
6017
6018 for (seg = program_headers;
6019 seg < program_headers + elf_header.e_phnum;
6020 ++seg)
6021 {
6022 if (seg->p_type != PT_LOAD)
6023 continue;
6024
6025 if (sec->sh_addr >= seg->p_vaddr
6026 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6027 {
6028 aux->seg_base = seg->p_vaddr;
6029 break;
6030 }
6031 }
6032 }
6033
6034 /* Second, build the unwind table from the contents of the unwind
6035 section. */
6036 size = sec->sh_size;
3f5e193b
NC		 6037 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6038 _("unwind table"));
57346661
AM		 6039 if (!table)
6040 return 0;
6041
1c0751b2
DA		 6042 unw_ent_size = 16;
6043 nentries = size / unw_ent_size;
6044 size = unw_ent_size * nentries;
57346661 6045
3f5e193b
NC		 6046 tep = aux->table = (struct hppa_unw_table_entry *)
6047 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6048
1c0751b2 6049 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6050 {
6051 unsigned int tmp1, tmp2;
6052
6053 tep->start.section = SHN_UNDEF;
6054 tep->end.section = SHN_UNDEF;
6055
1c0751b2
DA		 6056 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6057 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6058 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6059 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6060
6061 tep->start.offset += aux->seg_base;
6062 tep->end.offset += aux->seg_base;
57346661
AM		 6063
6064 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6065 tep->Millicode = (tmp1 >> 30) & 0x1;
6066 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6067 tep->Region_description = (tmp1 >> 27) & 0x3;
6068 tep->reserved1 = (tmp1 >> 26) & 0x1;
6069 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6070 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6071 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6072 tep->Args_stored = (tmp1 >> 15) & 0x1;
6073 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6074 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6075 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6076 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6077 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6078 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6079 tep->cxx_info = (tmp1 >> 8) & 0x1;
6080 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6081 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6082 tep->reserved2 = (tmp1 >> 5) & 0x1;
6083 tep->Save_SP = (tmp1 >> 4) & 0x1;
6084 tep->Save_RP = (tmp1 >> 3) & 0x1;
6085 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6086 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6087 tep->Cleanup_defined = tmp1 & 0x1;
6088
6089 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6090 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6091 tep->Large_frame = (tmp2 >> 29) & 0x1;
6092 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6093 tep->reserved4 = (tmp2 >> 27) & 0x1;
6094 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6095 }
6096 free (table);
6097
6098 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6099 for (relsec = section_headers;
6100 relsec < section_headers + elf_header.e_shnum;
6101 ++relsec)
6102 {
6103 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6104 || relsec->sh_info >= elf_header.e_shnum
6105 || section_headers + relsec->sh_info != sec)
57346661
AM		 6106 continue;
6107
6108 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6109 & rela, & nrelas))
6110 return 0;
6111
6112 for (rp = rela; rp < rela + nrelas; ++rp)
6113 {
aca88567
NC		 6114 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6115 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6116
6117 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6118 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6119 {
6120 warn (_("Skipping unexpected relocation type %s\n"), relname);
6121 continue;
6122 }
6123
6124 i = rp->r_offset / unw_ent_size;
6125
89fac5e3 6126 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6127 {
6128 case 0:
6129 aux->table[i].start.section = sym->st_shndx;
1e456d54 6130 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6131 break;
6132 case 1:
6133 aux->table[i].end.section = sym->st_shndx;
1e456d54 6134 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6135 break;
6136 default:
6137 break;
6138 }
6139 }
6140
6141 free (rela);
6142 }
6143
1c0751b2 6144 aux->table_len = nentries;
57346661
AM		 6145
6146 return 1;
6147}
6148
6149static int
2cf0635d 6150hppa_process_unwind (FILE * file)
57346661 6151{
57346661 6152 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6153 Elf_Internal_Shdr * unwsec = NULL;
6154 Elf_Internal_Shdr * strsec;
6155 Elf_Internal_Shdr * sec;
18bd398b 6156 unsigned long i;
57346661
AM		 6157
6158 memset (& aux, 0, sizeof (aux));
6159
c256ffe7
JJ		 6160 if (string_table == NULL)
6161 return 1;
57346661
AM		 6162
6163 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6164 {
c256ffe7 6165 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6166 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6167 {
6168 aux.nsyms = sec->sh_size / sec->sh_entsize;
6169 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6170
4fbb74a6 6171 strsec = section_headers + sec->sh_link;
59245841 6172 assert (aux.strtab == NULL);
3f5e193b
NC		 6173 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6174 1, strsec->sh_size,
6175 _("string table"));
c256ffe7 6176 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6177 }
18bd398b 6178 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6179 unwsec = sec;
6180 }
6181
6182 if (!unwsec)
6183 printf (_("\nThere are no unwind sections in this file.\n"));
6184
6185 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6186 {
18bd398b 6187 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6188 {
57346661
AM		 6189 printf (_("\nUnwind section "));
6190 printf (_("'%s'"), SECTION_NAME (sec));
6191
6192 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6193 (unsigned long) sec->sh_offset,
89fac5e3 6194 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6195
6196 slurp_hppa_unwind_table (file, &aux, sec);
6197 if (aux.table_len > 0)
6198 dump_hppa_unwind (&aux);
6199
6200 if (aux.table)
6201 free ((char *) aux.table);
6202 aux.table = NULL;
6203 }
6204 }
6205
6206 if (aux.symtab)
6207 free (aux.symtab);
6208 if (aux.strtab)
6209 free ((char *) aux.strtab);
6210
6211 return 1;
6212}
6213
0b6ae522
DJ		 6214struct arm_section
6215{
6216 unsigned char *data;
6217
6218 Elf_Internal_Shdr *sec;
6219 Elf_Internal_Rela *rela;
6220 unsigned long nrelas;
6221 unsigned int rel_type;
6222
6223 Elf_Internal_Rela *next_rela;
6224};
6225
6226struct arm_unw_aux_info
6227{
6228 FILE *file;
6229
6230 Elf_Internal_Sym *symtab; /* The symbol table. */
6231 unsigned long nsyms; /* Number of symbols. */
6232 char *strtab; /* The string table. */
6233 unsigned long strtab_size; /* Size of string table. */
6234};
6235
6236static const char *
6237arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6238 bfd_vma fn, struct absaddr addr)
6239{
6240 const char *procname;
6241 bfd_vma sym_offset;
6242
6243 if (addr.section == SHN_UNDEF)
6244 addr.offset = fn;
6245
6246 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6247 aux->strtab_size, addr, &procname,
6248 &sym_offset);
6249
6250 print_vma (fn, PREFIX_HEX);
6251
6252 if (procname)
6253 {
6254 fputs (" <", stdout);
6255 fputs (procname, stdout);
6256
6257 if (sym_offset)
6258 printf ("+0x%lx", (unsigned long) sym_offset);
6259 fputc ('>', stdout);
6260 }
6261
6262 return procname;
6263}
6264
6265static void
6266arm_free_section (struct arm_section *arm_sec)
6267{
6268 if (arm_sec->data != NULL)
6269 free (arm_sec->data);
6270
6271 if (arm_sec->rela != NULL)
6272 free (arm_sec->rela);
6273}
6274
6275static int
6276arm_section_get_word (struct arm_unw_aux_info *aux,
6277 struct arm_section *arm_sec,
6278 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6279 unsigned int *wordp, struct absaddr *addr)
6280{
6281 Elf_Internal_Rela *rp;
6282 Elf_Internal_Sym *sym;
6283 const char * relname;
6284 unsigned int word;
6285 bfd_boolean wrapped;
6286
6287 addr->section = SHN_UNDEF;
6288 addr->offset = 0;
6289
6290 if (sec != arm_sec->sec)
6291 {
6292 Elf_Internal_Shdr *relsec;
6293
6294 arm_free_section (arm_sec);
6295
6296 arm_sec->sec = sec;
6297 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6298 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6299 arm_sec->rela = NULL;
6300 arm_sec->nrelas = 0;
6301
6302 for (relsec = section_headers;
6303 relsec < section_headers + elf_header.e_shnum;
6304 ++relsec)
6305 {
6306 if (relsec->sh_info >= elf_header.e_shnum
6307 || section_headers + relsec->sh_info != sec)
6308 continue;
6309
6310 if (relsec->sh_type == SHT_REL)
6311 {
6312 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6313 relsec->sh_size,
6314 & arm_sec->rela, & arm_sec->nrelas))
6315 return 0;
6316 break;
6317 }
6318 else if (relsec->sh_type == SHT_RELA)
6319 {
6320 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6321 relsec->sh_size,
6322 & arm_sec->rela, & arm_sec->nrelas))
6323 return 0;
6324 break;
6325 }
6326 }
6327
6328 arm_sec->next_rela = arm_sec->rela;
6329 }
6330
6331 if (arm_sec->data == NULL)
6332 return 0;
6333
6334 word = byte_get (arm_sec->data + word_offset, 4);
6335
6336 wrapped = FALSE;
6337 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6338 {
6339 bfd_vma prelval, offset;
6340
6341 if (rp->r_offset > word_offset && !wrapped)
6342 {
6343 rp = arm_sec->rela;
6344 wrapped = TRUE;
6345 }
6346 if (rp->r_offset > word_offset)
6347 break;
6348
6349 if (rp->r_offset & 3)
6350 {
6351 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6352 (unsigned long) rp->r_offset);
6353 continue;
6354 }
6355
6356 if (rp->r_offset < word_offset)
6357 continue;
6358
fa197c1c
PB		 6359 switch (elf_header.e_machine)
6360 {
6361 case EM_ARM:
6362 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6363 break;
6364
6365 case EM_TI_C6000:
6366 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6367 break;
6368
6369 default:
6370 abort();
6371 }
0b6ae522 6372
fa197c1c
PB		 6373 if (streq (relname, "R_ARM_NONE")
6374 || streq (relname, "R_C6000_NONE"))
0b6ae522
DJ		 6375 continue;
6376
fa197c1c
PB		 6377 if (!(streq (relname, "R_ARM_PREL31")
6378 || streq (relname, "R_C6000_PREL31")))
0b6ae522
DJ		 6379 {
6380 warn (_("Skipping unexpected relocation type %s\n"), relname);
6381 continue;
6382 }
6383
6384 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6385
6386 if (arm_sec->rel_type == SHT_REL)
6387 {
6388 offset = word & 0x7fffffff;
6389 if (offset & 0x40000000)
6390 offset |= ~ (bfd_vma) 0x7fffffff;
6391 }
6392 else
6393 offset = rp->r_addend;
6394
6395 offset += sym->st_value;
6396 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6397
fa197c1c
PB		 6398 if (streq (relname, "R_C6000_PREL31"))
6399 prelval >>= 1;
6400
0b6ae522
DJ		 6401 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6402 addr->section = sym->st_shndx;
6403 addr->offset = offset;
6404 break;
6405 }
6406
6407 *wordp = word;
6408 arm_sec->next_rela = rp;
6409
6410 return 1;
6411}
6412
fa197c1c
PB		 6413static const char *tic6x_unwind_regnames[16] = {
6414 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6415 "A14", "A13", "A12", "A11", "A10",
6416 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6417
0b6ae522 6418static void
fa197c1c 6419decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6420{
fa197c1c
PB		 6421 int i;
6422
6423 for (i = 12; mask; mask >>= 1, i--)
6424 {
6425 if (mask & 1)
6426 {
6427 fputs (tic6x_unwind_regnames[i], stdout);
6428 if (mask > 1)
6429 fputs (", ", stdout);
6430 }
6431 }
6432}
0b6ae522
DJ		 6433
6434#define ADVANCE \
6435 if (remaining == 0 && more_words) \
6436 { \
6437 data_offset += 4; \
6438 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6439 data_offset, &word, &addr)) \
6440 return; \
6441 remaining = 4; \
6442 more_words--; \
6443 } \
6444
6445#define GET_OP(OP) \
6446 ADVANCE; \
6447 if (remaining) \
6448 { \
6449 remaining--; \
6450 (OP) = word >> 24; \
6451 word <<= 8; \
6452 } \
6453 else \
6454 { \
2b692964 6455 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6456 return; \
6457 } \
cc5914eb 6458 printf ("0x%02x ", OP)
0b6ae522 6459
fa197c1c
PB		 6460static void
6461decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6462 unsigned int word, unsigned int remaining,
6463 unsigned int more_words,
6464 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6465 struct arm_section *data_arm_sec)
6466{
6467 struct absaddr addr;
0b6ae522
DJ		 6468
6469 /* Decode the unwinding instructions. */
6470 while (1)
6471 {
6472 unsigned int op, op2;
6473
6474 ADVANCE;
6475 if (remaining == 0)
6476 break;
6477 remaining--;
6478 op = word >> 24;
6479 word <<= 8;
6480
cc5914eb 6481 printf (" 0x%02x ", op);
0b6ae522
DJ		 6482
6483 if ((op & 0xc0) == 0x00)
6484 {
6485 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6486
cc5914eb 6487 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6488 }
6489 else if ((op & 0xc0) == 0x40)
6490 {
6491 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6492
cc5914eb 6493 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6494 }
6495 else if ((op & 0xf0) == 0x80)
6496 {
6497 GET_OP (op2);
6498 if (op == 0x80 && op2 == 0)
6499 printf (_("Refuse to unwind"));
6500 else
6501 {
6502 unsigned int mask = ((op & 0x0f) << 8) | op2;
6503 int first = 1;
6504 int i;
2b692964 6505
0b6ae522
DJ		 6506 printf ("pop {");
6507 for (i = 0; i < 12; i++)
6508 if (mask & (1 << i))
6509 {
6510 if (first)
6511 first = 0;
6512 else
6513 printf (", ");
6514 printf ("r%d", 4 + i);
6515 }
6516 printf ("}");
6517 }
6518 }
6519 else if ((op & 0xf0) == 0x90)
6520 {
6521 if (op == 0x9d || op == 0x9f)
6522 printf (_(" [Reserved]"));
6523 else
cc5914eb 6524 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6525 }
6526 else if ((op & 0xf0) == 0xa0)
6527 {
6528 int end = 4 + (op & 0x07);
6529 int first = 1;
6530 int i;
61865e30 6531
0b6ae522
DJ		 6532 printf (" pop {");
6533 for (i = 4; i <= end; i++)
6534 {
6535 if (first)
6536 first = 0;
6537 else
6538 printf (", ");
6539 printf ("r%d", i);
6540 }
6541 if (op & 0x08)
6542 {
6543 if (first)
6544 printf (", ");
6545 printf ("r14");
6546 }
6547 printf ("}");
6548 }
6549 else if (op == 0xb0)
6550 printf (_(" finish"));
6551 else if (op == 0xb1)
6552 {
6553 GET_OP (op2);
6554 if (op2 == 0 || (op2 & 0xf0) != 0)
6555 printf (_("[Spare]"));
6556 else
6557 {
6558 unsigned int mask = op2 & 0x0f;
6559 int first = 1;
6560 int i;
61865e30 6561
0b6ae522
DJ		 6562 printf ("pop {");
6563 for (i = 0; i < 12; i++)
6564 if (mask & (1 << i))
6565 {
6566 if (first)
6567 first = 0;
6568 else
6569 printf (", ");
6570 printf ("r%d", i);
6571 }
6572 printf ("}");
6573 }
6574 }
6575 else if (op == 0xb2)
6576 {
b115cf96 6577 unsigned char buf[9];
0b6ae522
DJ		 6578 unsigned int i, len;
6579 unsigned long offset;
61865e30 6580
b115cf96 6581 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6582 {
6583 GET_OP (buf[i]);
6584 if ((buf[i] & 0x80) == 0)
6585 break;
6586 }
6587 assert (i < sizeof (buf));
6588 offset = read_uleb128 (buf, &len);
6589 assert (len == i + 1);
6590 offset = offset * 4 + 0x204;
cc5914eb 6591 printf ("vsp = vsp + %ld", offset);
0b6ae522 6592 }
61865e30 6593 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6594 {
61865e30
NC		 6595 unsigned int first, last;
6596
6597 GET_OP (op2);
6598 first = op2 >> 4;
6599 last = op2 & 0x0f;
6600 if (op == 0xc8)
6601 first = first + 16;
6602 printf ("pop {D%d", first);
6603 if (last)
6604 printf ("-D%d", first + last);
6605 printf ("}");
6606 }
6607 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6608 {
6609 unsigned int count = op & 0x07;
6610
6611 printf ("pop {D8");
6612 if (count)
6613 printf ("-D%d", 8 + count);
6614 printf ("}");
6615 }
6616 else if (op >= 0xc0 && op <= 0xc5)
6617 {
6618 unsigned int count = op & 0x07;
6619
6620 printf (" pop {wR10");
6621 if (count)
6622 printf ("-wR%d", 10 + count);
6623 printf ("}");
6624 }
6625 else if (op == 0xc6)
6626 {
6627 unsigned int first, last;
6628
6629 GET_OP (op2);
6630 first = op2 >> 4;
6631 last = op2 & 0x0f;
6632 printf ("pop {wR%d", first);
6633 if (last)
6634 printf ("-wR%d", first + last);
6635 printf ("}");
6636 }
6637 else if (op == 0xc7)
6638 {
6639 GET_OP (op2);
6640 if (op2 == 0 || (op2 & 0xf0) != 0)
6641 printf (_("[Spare]"));
0b6ae522
DJ		 6642 else
6643 {
61865e30
NC		 6644 unsigned int mask = op2 & 0x0f;
6645 int first = 1;
6646 int i;
6647
6648 printf ("pop {");
6649 for (i = 0; i < 4; i++)
6650 if (mask & (1 << i))
6651 {
6652 if (first)
6653 first = 0;
6654 else
6655 printf (", ");
6656 printf ("wCGR%d", i);
6657 }
6658 printf ("}");
0b6ae522
DJ		 6659 }
6660 }
61865e30
NC		 6661 else
6662 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6663 printf ("\n");
6664 }
fa197c1c
PB		 6665}
6666
6667static void
6668decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6669 unsigned int word, unsigned int remaining,
6670 unsigned int more_words,
6671 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6672 struct arm_section *data_arm_sec)
6673{
6674 struct absaddr addr;
6675
6676 /* Decode the unwinding instructions. */
6677 while (1)
6678 {
6679 unsigned int op, op2;
6680
6681 ADVANCE;
6682 if (remaining == 0)
6683 break;
6684 remaining--;
6685 op = word >> 24;
6686 word <<= 8;
6687
6688 printf (_(" 0x%02x "), op);
6689
6690 if ((op & 0xc0) == 0x00)
6691 {
6692 int offset = ((op & 0x3f) << 3) + 8;
6693 printf (_(" sp = sp + %d"), offset);
6694 }
6695 else if ((op & 0xc0) == 0x80)
6696 {
6697 GET_OP (op2);
6698 if (op == 0x80 && op2 == 0)
6699 printf (_("Refuse to unwind"));
6700 else
6701 {
6702 unsigned int mask = ((op & 0x1f) << 8) | op2;
6703 if (op & 0x20)
6704 printf ("pop compact {");
6705 else
6706 printf ("pop {");
6707
6708 decode_tic6x_unwind_regmask (mask);
6709 printf("}");
6710 }
6711 }
6712 else if ((op & 0xf0) == 0xc0)
6713 {
6714 unsigned int reg;
6715 unsigned int nregs;
6716 unsigned int i;
6717 const char *name;
6718 struct {
6719 unsigned int offset;
6720 unsigned int reg;
6721 } regpos[16];
6722
6723 /* Scan entire instruction first so that GET_OP output is not
6724 interleaved with disassembly. */
6725 nregs = 0;
6726 for (i = 0; nregs < (op & 0xf); i++)
6727 {
6728 GET_OP (op2);
6729 reg = op2 >> 4;
6730 if (reg != 0xf)
6731 {
6732 regpos[nregs].offset = i * 2;
6733 regpos[nregs].reg = reg;
6734 nregs++;
6735 }
6736
6737 reg = op2 & 0xf;
6738 if (reg != 0xf)
6739 {
6740 regpos[nregs].offset = i * 2 + 1;
6741 regpos[nregs].reg = reg;
6742 nregs++;
6743 }
6744 }
6745
6746 printf (_("pop frame {"));
6747 reg = nregs - 1;
6748 for (i = i * 2; i > 0; i--)
6749 {
6750 if (regpos[reg].offset == i - 1)
6751 {
6752 name = tic6x_unwind_regnames[regpos[reg].reg];
6753 if (reg > 0)
6754 reg--;
6755 }
6756 else
6757 name = _("[pad]");
6758
6759 fputs (name, stdout);
6760 if (i > 1)
6761 printf (", ");
6762 }
6763
6764 printf ("}");
6765 }
6766 else if (op == 0xd0)
6767 printf (" MOV FP, SP");
6768 else if (op == 0xd1)
6769 printf (" __c6xabi_pop_rts");
6770 else if (op == 0xd2)
6771 {
6772 unsigned char buf[9];
6773 unsigned int i, len;
6774 unsigned long offset;
6775 for (i = 0; i < sizeof (buf); i++)
6776 {
6777 GET_OP (buf[i]);
6778 if ((buf[i] & 0x80) == 0)
6779 break;
6780 }
6781 assert (i < sizeof (buf));
6782 offset = read_uleb128 (buf, &len);
6783 assert (len == i + 1);
6784 offset = offset * 8 + 0x408;
6785 printf (_("sp = sp + %ld"), offset);
6786 }
6787 else if ((op & 0xf0) == 0xe0)
6788 {
6789 if ((op & 0x0f) == 7)
6790 printf (" RETURN");
6791 else
6792 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6793 }
6794 else
6795 {
6796 printf (_(" [unsupported opcode]"));
6797 }
6798 putchar ('\n');
6799 }
6800}
6801
6802static bfd_vma
6803expand_prel31 (bfd_vma word, bfd_vma where)
6804{
6805 bfd_vma offset;
6806
6807 offset = word & 0x7fffffff;
6808 if (offset & 0x40000000)
6809 offset |= ~ (bfd_vma) 0x7fffffff;
6810
6811 if (elf_header.e_machine == EM_TI_C6000)
6812 offset <<= 1;
6813
6814 return offset + where;
6815}
6816
6817static void
6818decode_arm_unwind (struct arm_unw_aux_info *aux,
6819 unsigned int word, unsigned int remaining,
6820 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6821 struct arm_section *data_arm_sec)
6822{
6823 int per_index;
6824 unsigned int more_words = 0;
6825 struct absaddr addr;
6826
6827 if (remaining == 0)
6828 {
6829 /* Fetch the first word. */
6830 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6831 &word, &addr))
6832 return;
6833 remaining = 4;
6834 }
6835
6836 if ((word & 0x80000000) == 0)
6837 {
6838 /* Expand prel31 for personality routine. */
6839 bfd_vma fn;
6840 const char *procname;
6841
6842 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6843 printf (_(" Personality routine: "));
6844 procname = arm_print_vma_and_name (aux, fn, addr);
6845 fputc ('\n', stdout);
6846
6847 /* The GCC personality routines use the standard compact
6848 encoding, starting with one byte giving the number of
6849 words. */
6850 if (procname != NULL
6851 && (const_strneq (procname, "__gcc_personality_v0")
6852 || const_strneq (procname, "__gxx_personality_v0")
6853 || const_strneq (procname, "__gcj_personality_v0")
6854 || const_strneq (procname, "__gnu_objc_personality_v0")))
6855 {
6856 remaining = 0;
6857 more_words = 1;
6858 ADVANCE;
6859 if (!remaining)
6860 {
6861 printf (_(" [Truncated data]\n"));
6862 return;
6863 }
6864 more_words = word >> 24;
6865 word <<= 8;
6866 remaining--;
6867 per_index = -1;
6868 }
6869 else
6870 return;
6871 }
6872 else
6873 {
6874
6875 per_index = (word >> 24) & 0x7f;
6876 printf (_(" Compact model %d\n"), per_index);
6877 if (per_index == 0)
6878 {
6879 more_words = 0;
6880 word <<= 8;
6881 remaining--;
6882 }
6883 else if (per_index < 3)
6884 {
6885 more_words = (word >> 16) & 0xff;
6886 word <<= 16;
6887 remaining -= 2;
6888 }
6889 }
6890
6891 switch (elf_header.e_machine)
6892 {
6893 case EM_ARM:
6894 if (per_index < 3)
6895 {
6896 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6897 data_offset, data_sec, data_arm_sec);
6898 }
6899 else
6900 printf (" [reserved]\n");
6901 break;
6902
6903 case EM_TI_C6000:
6904 if (per_index < 3)
6905 {
6906 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6907 data_offset, data_sec, data_arm_sec);
6908 }
6909 else if (per_index < 5)
6910 {
6911 if (((word >> 17) & 0x7f) == 0x7f)
6912 printf (_(" Restore stack from frame pointer\n"));
6913 else
6914 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6915 printf (_(" Registers restored: "));
6916 if (per_index == 4)
6917 printf (" (compact) ");
6918 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6919 putchar ('\n');
6920 printf (_(" Return register: %s\n"),
6921 tic6x_unwind_regnames[word & 0xf]);
6922 }
6923 else
6924 printf (" [reserved]\n");
6925 break;
6926
6927 default:
6928 abort ();
6929 }
0b6ae522
DJ		 6930
6931 /* Decode the descriptors. Not implemented. */
6932}
6933
6934static void
6935dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6936{
6937 struct arm_section exidx_arm_sec, extab_arm_sec;
6938 unsigned int i, exidx_len;
6939
6940 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6941 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6942 exidx_len = exidx_sec->sh_size / 8;
6943
6944 for (i = 0; i < exidx_len; i++)
6945 {
6946 unsigned int exidx_fn, exidx_entry;
6947 struct absaddr fn_addr, entry_addr;
6948 bfd_vma fn;
6949
6950 fputc ('\n', stdout);
6951
6952 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6953 8 * i, &exidx_fn, &fn_addr)
6954 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6955 8 * i + 4, &exidx_entry, &entry_addr))
6956 {
6957 arm_free_section (&exidx_arm_sec);
6958 arm_free_section (&extab_arm_sec);
6959 return;
6960 }
6961
fa197c1c 6962 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522
DJ		 6963
6964 arm_print_vma_and_name (aux, fn, entry_addr);
6965 fputs (": ", stdout);
6966
6967 if (exidx_entry == 1)
6968 {
6969 print_vma (exidx_entry, PREFIX_HEX);
6970 fputs (" [cantunwind]\n", stdout);
6971 }
6972 else if (exidx_entry & 0x80000000)
6973 {
6974 print_vma (exidx_entry, PREFIX_HEX);
6975 fputc ('\n', stdout);
6976 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6977 }
6978 else
6979 {
8f73510c 6980 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6981 Elf_Internal_Shdr *table_sec;
6982
6983 fputs ("@", stdout);
fa197c1c 6984 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 6985 print_vma (table, PREFIX_HEX);
6986 printf ("\n");
6987
6988 /* Locate the matching .ARM.extab. */
6989 if (entry_addr.section != SHN_UNDEF
6990 && entry_addr.section < elf_header.e_shnum)
6991 {
6992 table_sec = section_headers + entry_addr.section;
6993 table_offset = entry_addr.offset;
6994 }
6995 else
6996 {
6997 table_sec = find_section_by_address (table);
6998 if (table_sec != NULL)
6999 table_offset = table - table_sec->sh_addr;
7000 }
7001 if (table_sec == NULL)
7002 {
7003 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7004 (unsigned long) table);
7005 continue;
7006 }
7007 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7008 &extab_arm_sec);
7009 }
7010 }
7011
7012 printf ("\n");
7013
7014 arm_free_section (&exidx_arm_sec);
7015 arm_free_section (&extab_arm_sec);
7016}
7017
fa197c1c 7018/* Used for both ARM and C6X unwinding tables. */
0b6ae522
DJ		 7019static int
7020arm_process_unwind (FILE *file)
7021{
7022 struct arm_unw_aux_info aux;
7023 Elf_Internal_Shdr *unwsec = NULL;
7024 Elf_Internal_Shdr *strsec;
7025 Elf_Internal_Shdr *sec;
7026 unsigned long i;
fa197c1c 7027 unsigned int sec_type;
0b6ae522
DJ		 7028
7029 memset (& aux, 0, sizeof (aux));
7030 aux.file = file;
7031
fa197c1c
PB		 7032 switch (elf_header.e_machine)
7033 {
7034 case EM_ARM:
7035 sec_type = SHT_ARM_EXIDX;
7036 break;
7037
7038 case EM_TI_C6000:
7039 sec_type = SHT_C6000_UNWIND;
7040 break;
7041
7042 default:
7043 abort();
7044 }
7045
0b6ae522
DJ		 7046 if (string_table == NULL)
7047 return 1;
7048
7049 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7050 {
7051 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7052 {
7053 aux.nsyms = sec->sh_size / sec->sh_entsize;
7054 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7055
7056 strsec = section_headers + sec->sh_link;
59245841 7057 assert (aux.strtab == NULL);
0b6ae522
DJ		 7058 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7059 1, strsec->sh_size, _("string table"));
7060 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7061 }
fa197c1c 7062 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7063 unwsec = sec;
7064 }
7065
7066 if (!unwsec)
7067 printf (_("\nThere are no unwind sections in this file.\n"));
7068
7069 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7070 {
fa197c1c 7071 if (sec->sh_type == sec_type)
0b6ae522
DJ		 7072 {
7073 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7074 SECTION_NAME (sec),
7075 (unsigned long) sec->sh_offset,
7076 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7077
7078 dump_arm_unwind (&aux, sec);
7079 }
7080 }
7081
7082 if (aux.symtab)
7083 free (aux.symtab);
7084 if (aux.strtab)
7085 free ((char *) aux.strtab);
7086
7087 return 1;
7088}
7089
57346661 7090static int
2cf0635d 7091process_unwind (FILE * file)
57346661 7092{
2cf0635d
NC		 7093 struct unwind_handler
7094 {
57346661 7095 int machtype;
2cf0635d
NC		 7096 int (* handler)(FILE *);
7097 } handlers[] =
7098 {
0b6ae522 7099 { EM_ARM, arm_process_unwind },
57346661
AM		 7100 { EM_IA_64, ia64_process_unwind },
7101 { EM_PARISC, hppa_process_unwind },
fa197c1c 7102 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7103 { 0, 0 }
7104 };
7105 int i;
7106
7107 if (!do_unwind)
7108 return 1;
7109
7110 for (i = 0; handlers[i].handler != NULL; i++)
7111 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7112 return handlers[i].handler (file);
57346661
AM		 7113
7114 printf (_("\nThere are no unwind sections in this file.\n"));
7115 return 1;
7116}
7117
252b5132 7118static void
2cf0635d 7119dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7120{
7121 switch (entry->d_tag)
7122 {
7123 case DT_MIPS_FLAGS:
7124 if (entry->d_un.d_val == 0)
2b692964 7125 printf (_("NONE\n"));
252b5132
RH		 7126 else
7127 {
7128 static const char * opts[] =
7129 {
7130 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7131 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7132 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7133 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7134 "RLD_ORDER_SAFE"
7135 };
7136 unsigned int cnt;
7137 int first = 1;
2b692964 7138
60bca95a 7139 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7140 if (entry->d_un.d_val & (1 << cnt))
7141 {
7142 printf ("%s%s", first ? "" : " ", opts[cnt]);
7143 first = 0;
7144 }
7145 puts ("");
7146 }
7147 break;
103f02d3 7148
252b5132 7149 case DT_MIPS_IVERSION:
d79b3d50 7150 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 7151 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7152 else
2b692964 7153 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 7154 break;
103f02d3 7155
252b5132
RH		 7156 case DT_MIPS_TIME_STAMP:
7157 {
7158 char timebuf[20];
2cf0635d 7159 struct tm * tmp;
50da7a9c 7160
91d6fa6a
NC		 7161 time_t atime = entry->d_un.d_val;
7162 tmp = gmtime (&atime);
e9e44622
JJ		 7163 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7164 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7165 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 7166 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 7167 }
7168 break;
103f02d3 7169
252b5132
RH		 7170 case DT_MIPS_RLD_VERSION:
7171 case DT_MIPS_LOCAL_GOTNO:
7172 case DT_MIPS_CONFLICTNO:
7173 case DT_MIPS_LIBLISTNO:
7174 case DT_MIPS_SYMTABNO:
7175 case DT_MIPS_UNREFEXTNO:
7176 case DT_MIPS_HIPAGENO:
7177 case DT_MIPS_DELTA_CLASS_NO:
7178 case DT_MIPS_DELTA_INSTANCE_NO:
7179 case DT_MIPS_DELTA_RELOC_NO:
7180 case DT_MIPS_DELTA_SYM_NO:
7181 case DT_MIPS_DELTA_CLASSSYM_NO:
7182 case DT_MIPS_COMPACT_SIZE:
7183 printf ("%ld\n", (long) entry->d_un.d_ptr);
7184 break;
103f02d3
UD		 7185
7186 default:
0af1713e 7187 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 7188 }
7189}
7190
103f02d3 7191static void
2cf0635d 7192dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7193{
7194 switch (entry->d_tag)
7195 {
7196 case DT_HP_DLD_FLAGS:
7197 {
7198 static struct
7199 {
7200 long int bit;
2cf0635d 7201 const char * str;
5e220199
NC		 7202 }
7203 flags[] =
7204 {
7205 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7206 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7207 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7208 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7209 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7210 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7211 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7212 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7213 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7214 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7215 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7216 { DT_HP_GST, "HP_GST" },
7217 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7218 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7219 { DT_HP_NODELETE, "HP_NODELETE" },
7220 { DT_HP_GROUP, "HP_GROUP" },
7221 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7222 };
103f02d3 7223 int first = 1;
5e220199 7224 size_t cnt;
f7a99963 7225 bfd_vma val = entry->d_un.d_val;
103f02d3 7226
60bca95a 7227 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7228 if (val & flags[cnt].bit)
30800947
NC		 7229 {
7230 if (! first)
7231 putchar (' ');
7232 fputs (flags[cnt].str, stdout);
7233 first = 0;
7234 val ^= flags[cnt].bit;
7235 }
76da6bbe 7236
103f02d3 7237 if (val != 0 || first)
f7a99963
NC		 7238 {
7239 if (! first)
7240 putchar (' ');
7241 print_vma (val, HEX);
7242 }
103f02d3
UD		 7243 }
7244 break;
76da6bbe 7245
252b5132 7246 default:
f7a99963
NC		 7247 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7248 break;
252b5132 7249 }
35b1837e 7250 putchar ('\n');
252b5132
RH		 7251}
7252
28f997cf
TG		 7253#ifdef BFD64
7254
7255/* VMS vs Unix time offset and factor. */
7256
7257#define VMS_EPOCH_OFFSET 35067168000000000LL
7258#define VMS_GRANULARITY_FACTOR 10000000
7259
7260/* Display a VMS time in a human readable format. */
7261
7262static void
7263print_vms_time (bfd_int64_t vmstime)
7264{
7265 struct tm *tm;
7266 time_t unxtime;
7267
7268 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7269 tm = gmtime (&unxtime);
7270 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7271 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7272 tm->tm_hour, tm->tm_min, tm->tm_sec);
7273}
7274#endif /* BFD64 */
7275
ecc51f48 7276static void
2cf0635d 7277dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7278{
7279 switch (entry->d_tag)
7280 {
0de14b54 7281 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7282 /* First 3 slots reserved. */
ecc51f48
NC		 7283 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7284 printf (" -- ");
7285 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7286 break;
7287
28f997cf
TG		 7288 case DT_IA_64_VMS_LINKTIME:
7289#ifdef BFD64
7290 print_vms_time (entry->d_un.d_val);
7291#endif
7292 break;
7293
7294 case DT_IA_64_VMS_LNKFLAGS:
7295 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7296 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7297 printf (" CALL_DEBUG");
7298 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7299 printf (" NOP0BUFS");
7300 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7301 printf (" P0IMAGE");
7302 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7303 printf (" MKTHREADS");
7304 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7305 printf (" UPCALLS");
7306 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7307 printf (" IMGSTA");
7308 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7309 printf (" INITIALIZE");
7310 if (entry->d_un.d_val & VMS_LF_MAIN)
7311 printf (" MAIN");
7312 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7313 printf (" EXE_INIT");
7314 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7315 printf (" TBK_IN_IMG");
7316 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7317 printf (" DBG_IN_IMG");
7318 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7319 printf (" TBK_IN_DSF");
7320 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7321 printf (" DBG_IN_DSF");
7322 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7323 printf (" SIGNATURES");
7324 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7325 printf (" REL_SEG_OFF");
7326 break;
7327
bdf4d63a
JJ		 7328 default:
7329 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7330 break;
ecc51f48 7331 }
bdf4d63a 7332 putchar ('\n');
ecc51f48
NC		 7333}
7334
252b5132 7335static int
2cf0635d 7336get_32bit_dynamic_section (FILE * file)
252b5132 7337{
2cf0635d
NC		 7338 Elf32_External_Dyn * edyn;
7339 Elf32_External_Dyn * ext;
7340 Elf_Internal_Dyn * entry;
103f02d3 7341
3f5e193b
NC		 7342 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7343 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7344 if (!edyn)
7345 return 0;
103f02d3 7346
ba2685cc
AM		 7347/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7348 might not have the luxury of section headers. Look for the DT_NULL
7349 terminator to determine the number of entries. */
7350 for (ext = edyn, dynamic_nent = 0;
7351 (char *) ext < (char *) edyn + dynamic_size;
7352 ext++)
7353 {
7354 dynamic_nent++;
7355 if (BYTE_GET (ext->d_tag) == DT_NULL)
7356 break;
7357 }
252b5132 7358
3f5e193b
NC		 7359 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7360 sizeof (* entry));
b2d38a17 7361 if (dynamic_section == NULL)
252b5132 7362 {
9ea033b2
NC		 7363 error (_("Out of memory\n"));
7364 free (edyn);
7365 return 0;
7366 }
252b5132 7367
fb514b26 7368 for (ext = edyn, entry = dynamic_section;
ba2685cc 7369 entry < dynamic_section + dynamic_nent;
fb514b26 7370 ext++, entry++)
9ea033b2 7371 {
fb514b26
AM		 7372 entry->d_tag = BYTE_GET (ext->d_tag);
7373 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7374 }
7375
9ea033b2
NC		 7376 free (edyn);
7377
7378 return 1;
7379}
7380
7381static int
2cf0635d 7382get_64bit_dynamic_section (FILE * file)
9ea033b2 7383{
2cf0635d
NC		 7384 Elf64_External_Dyn * edyn;
7385 Elf64_External_Dyn * ext;
7386 Elf_Internal_Dyn * entry;
103f02d3 7387
3f5e193b
NC		 7388 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7389 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7390 if (!edyn)
7391 return 0;
103f02d3 7392
ba2685cc
AM		 7393/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7394 might not have the luxury of section headers. Look for the DT_NULL
7395 terminator to determine the number of entries. */
7396 for (ext = edyn, dynamic_nent = 0;
7397 (char *) ext < (char *) edyn + dynamic_size;
7398 ext++)
7399 {
7400 dynamic_nent++;
66543521 7401 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7402 break;
7403 }
252b5132 7404
3f5e193b
NC		 7405 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7406 sizeof (* entry));
b2d38a17 7407 if (dynamic_section == NULL)
252b5132
RH		 7408 {
7409 error (_("Out of memory\n"));
7410 free (edyn);
7411 return 0;
7412 }
7413
fb514b26 7414 for (ext = edyn, entry = dynamic_section;
ba2685cc 7415 entry < dynamic_section + dynamic_nent;
fb514b26 7416 ext++, entry++)
252b5132 7417 {
66543521
AM		 7418 entry->d_tag = BYTE_GET (ext->d_tag);
7419 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7420 }
7421
7422 free (edyn);
7423
9ea033b2
NC		 7424 return 1;
7425}
7426
e9e44622
JJ		 7427static void
7428print_dynamic_flags (bfd_vma flags)
d1133906 7429{
e9e44622 7430 int first = 1;
13ae64f3 7431
d1133906
NC		 7432 while (flags)
7433 {
7434 bfd_vma flag;
7435
7436 flag = flags & - flags;
7437 flags &= ~ flag;
7438
e9e44622
JJ		 7439 if (first)
7440 first = 0;
7441 else
7442 putc (' ', stdout);
13ae64f3 7443
d1133906
NC		 7444 switch (flag)
7445 {
e9e44622
JJ		 7446 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7447 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7448 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7449 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7450 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7451 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7452 }
7453 }
e9e44622 7454 puts ("");
d1133906
NC		 7455}
7456
b2d38a17
NC		 7457/* Parse and display the contents of the dynamic section. */
7458
9ea033b2 7459static int
2cf0635d 7460process_dynamic_section (FILE * file)
9ea033b2 7461{
2cf0635d 7462 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7463
7464 if (dynamic_size == 0)
7465 {
7466 if (do_dynamic)
b2d38a17 7467 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7468
7469 return 1;
7470 }
7471
7472 if (is_32bit_elf)
7473 {
b2d38a17 7474 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7475 return 0;
7476 }
b2d38a17 7477 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7478 return 0;
7479
252b5132
RH		 7480 /* Find the appropriate symbol table. */
7481 if (dynamic_symbols == NULL)
7482 {
86dba8ee
AM		 7483 for (entry = dynamic_section;
7484 entry < dynamic_section + dynamic_nent;
7485 ++entry)
252b5132 7486 {
c8286bd1 7487 Elf_Internal_Shdr section;
252b5132
RH		 7488
7489 if (entry->d_tag != DT_SYMTAB)
7490 continue;
7491
7492 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7493
7494 /* Since we do not know how big the symbol table is,
7495 we default to reading in the entire file (!) and
7496 processing that. This is overkill, I know, but it
e3c8793a 7497 should work. */
d93f0186 7498 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7499
fb52b2f4
NC		 7500 if (archive_file_offset != 0)
7501 section.sh_size = archive_file_size - section.sh_offset;
7502 else
7503 {
7504 if (fseek (file, 0, SEEK_END))
591a748a 7505 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7506
7507 section.sh_size = ftell (file) - section.sh_offset;
7508 }
252b5132 7509
9ea033b2 7510 if (is_32bit_elf)
9ad5cbcf 7511 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7512 else
9ad5cbcf 7513 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7514
9ad5cbcf 7515 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7516 if (num_dynamic_syms < 1)
252b5132
RH		 7517 {
7518 error (_("Unable to determine the number of symbols to load\n"));
7519 continue;
7520 }
7521
9ad5cbcf 7522 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7523 }
7524 }
7525
7526 /* Similarly find a string table. */
7527 if (dynamic_strings == NULL)
7528 {
86dba8ee
AM		 7529 for (entry = dynamic_section;
7530 entry < dynamic_section + dynamic_nent;
7531 ++entry)
252b5132
RH		 7532 {
7533 unsigned long offset;
b34976b6 7534 long str_tab_len;
252b5132
RH		 7535
7536 if (entry->d_tag != DT_STRTAB)
7537 continue;
7538
7539 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7540
7541 /* Since we do not know how big the string table is,
7542 we default to reading in the entire file (!) and
7543 processing that. This is overkill, I know, but it
e3c8793a 7544 should work. */
252b5132 7545
d93f0186 7546 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7547
7548 if (archive_file_offset != 0)
7549 str_tab_len = archive_file_size - offset;
7550 else
7551 {
7552 if (fseek (file, 0, SEEK_END))
7553 error (_("Unable to seek to end of file\n"));
7554 str_tab_len = ftell (file) - offset;
7555 }
252b5132
RH		 7556
7557 if (str_tab_len < 1)
7558 {
7559 error
7560 (_("Unable to determine the length of the dynamic string table\n"));
7561 continue;
7562 }
7563
3f5e193b
NC		 7564 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7565 str_tab_len,
7566 _("dynamic string table"));
59245841 7567 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7568 break;
7569 }
7570 }
7571
7572 /* And find the syminfo section if available. */
7573 if (dynamic_syminfo == NULL)
7574 {
3e8bba36 7575 unsigned long syminsz = 0;
252b5132 7576
86dba8ee
AM		 7577 for (entry = dynamic_section;
7578 entry < dynamic_section + dynamic_nent;
7579 ++entry)
252b5132
RH		 7580 {
7581 if (entry->d_tag == DT_SYMINENT)
7582 {
7583 /* Note: these braces are necessary to avoid a syntax
7584 error from the SunOS4 C compiler. */
7585 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7586 }
7587 else if (entry->d_tag == DT_SYMINSZ)
7588 syminsz = entry->d_un.d_val;
7589 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7590 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7591 syminsz);
252b5132
RH		 7592 }
7593
7594 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7595 {
2cf0635d
NC		 7596 Elf_External_Syminfo * extsyminfo;
7597 Elf_External_Syminfo * extsym;
7598 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7599
7600 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7601 extsyminfo = (Elf_External_Syminfo *)
7602 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7603 _("symbol information"));
a6e9f9df
AM		 7604 if (!extsyminfo)
7605 return 0;
252b5132 7606
3f5e193b 7607 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7608 if (dynamic_syminfo == NULL)
7609 {
7610 error (_("Out of memory\n"));
7611 return 0;
7612 }
7613
7614 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7615 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7616 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7617 ++syminfo, ++extsym)
252b5132 7618 {
86dba8ee
AM		 7619 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7620 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7621 }
7622
7623 free (extsyminfo);
7624 }
7625 }
7626
7627 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7628 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7629 dynamic_addr, dynamic_nent);
252b5132
RH		 7630 if (do_dynamic)
7631 printf (_(" Tag Type Name/Value\n"));
7632
86dba8ee
AM		 7633 for (entry = dynamic_section;
7634 entry < dynamic_section + dynamic_nent;
7635 entry++)
252b5132
RH		 7636 {
7637 if (do_dynamic)
f7a99963 7638 {
2cf0635d 7639 const char * dtype;
e699b9ff 7640
f7a99963
NC		 7641 putchar (' ');
7642 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7643 dtype = get_dynamic_type (entry->d_tag);
7644 printf (" (%s)%*s", dtype,
7645 ((is_32bit_elf ? 27 : 19)
7646 - (int) strlen (dtype)),
f7a99963
NC		 7647 " ");
7648 }
252b5132
RH		 7649
7650 switch (entry->d_tag)
7651 {
d1133906
NC		 7652 case DT_FLAGS:
7653 if (do_dynamic)
e9e44622 7654 print_dynamic_flags (entry->d_un.d_val);
d1133906 7655 break;
76da6bbe 7656
252b5132
RH		 7657 case DT_AUXILIARY:
7658 case DT_FILTER:
019148e4
L		 7659 case DT_CONFIG:
7660 case DT_DEPAUDIT:
7661 case DT_AUDIT:
252b5132
RH		 7662 if (do_dynamic)
7663 {
019148e4 7664 switch (entry->d_tag)
b34976b6 7665 {
019148e4
L		 7666 case DT_AUXILIARY:
7667 printf (_("Auxiliary library"));
7668 break;
7669
7670 case DT_FILTER:
7671 printf (_("Filter library"));
7672 break;
7673
b34976b6 7674 case DT_CONFIG:
019148e4
L		 7675 printf (_("Configuration file"));
7676 break;
7677
7678 case DT_DEPAUDIT:
7679 printf (_("Dependency audit library"));
7680 break;
7681
7682 case DT_AUDIT:
7683 printf (_("Audit library"));
7684 break;
7685 }
252b5132 7686
d79b3d50
NC		 7687 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7688 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7689 else
f7a99963
NC		 7690 {
7691 printf (": ");
7692 print_vma (entry->d_un.d_val, PREFIX_HEX);
7693 putchar ('\n');
7694 }
252b5132
RH		 7695 }
7696 break;
7697
dcefbbbd 7698 case DT_FEATURE:
252b5132
RH		 7699 if (do_dynamic)
7700 {
7701 printf (_("Flags:"));
86f55779 7702
252b5132
RH		 7703 if (entry->d_un.d_val == 0)
7704 printf (_(" None\n"));
7705 else
7706 {
7707 unsigned long int val = entry->d_un.d_val;
86f55779 7708
252b5132
RH		 7709 if (val & DTF_1_PARINIT)
7710 {
7711 printf (" PARINIT");
7712 val ^= DTF_1_PARINIT;
7713 }
dcefbbbd
L		 7714 if (val & DTF_1_CONFEXP)
7715 {
7716 printf (" CONFEXP");
7717 val ^= DTF_1_CONFEXP;
7718 }
252b5132
RH		 7719 if (val != 0)
7720 printf (" %lx", val);
7721 puts ("");
7722 }
7723 }
7724 break;
7725
7726 case DT_POSFLAG_1:
7727 if (do_dynamic)
7728 {
7729 printf (_("Flags:"));
86f55779 7730
252b5132
RH		 7731 if (entry->d_un.d_val == 0)
7732 printf (_(" None\n"));
7733 else
7734 {
7735 unsigned long int val = entry->d_un.d_val;
86f55779 7736
252b5132
RH		 7737 if (val & DF_P1_LAZYLOAD)
7738 {
7739 printf (" LAZYLOAD");
7740 val ^= DF_P1_LAZYLOAD;
7741 }
7742 if (val & DF_P1_GROUPPERM)
7743 {
7744 printf (" GROUPPERM");
7745 val ^= DF_P1_GROUPPERM;
7746 }
7747 if (val != 0)
7748 printf (" %lx", val);
7749 puts ("");
7750 }
7751 }
7752 break;
7753
7754 case DT_FLAGS_1:
7755 if (do_dynamic)
7756 {
7757 printf (_("Flags:"));
7758 if (entry->d_un.d_val == 0)
7759 printf (_(" None\n"));
7760 else
7761 {
7762 unsigned long int val = entry->d_un.d_val;
86f55779 7763
252b5132
RH		 7764 if (val & DF_1_NOW)
7765 {
7766 printf (" NOW");
7767 val ^= DF_1_NOW;
7768 }
7769 if (val & DF_1_GLOBAL)
7770 {
7771 printf (" GLOBAL");
7772 val ^= DF_1_GLOBAL;
7773 }
7774 if (val & DF_1_GROUP)
7775 {
7776 printf (" GROUP");
7777 val ^= DF_1_GROUP;
7778 }
7779 if (val & DF_1_NODELETE)
7780 {
7781 printf (" NODELETE");
7782 val ^= DF_1_NODELETE;
7783 }
7784 if (val & DF_1_LOADFLTR)
7785 {
7786 printf (" LOADFLTR");
7787 val ^= DF_1_LOADFLTR;
7788 }
7789 if (val & DF_1_INITFIRST)
7790 {
7791 printf (" INITFIRST");
7792 val ^= DF_1_INITFIRST;
7793 }
7794 if (val & DF_1_NOOPEN)
7795 {
7796 printf (" NOOPEN");
7797 val ^= DF_1_NOOPEN;
7798 }
7799 if (val & DF_1_ORIGIN)
7800 {
7801 printf (" ORIGIN");
7802 val ^= DF_1_ORIGIN;
7803 }
7804 if (val & DF_1_DIRECT)
7805 {
7806 printf (" DIRECT");
7807 val ^= DF_1_DIRECT;
7808 }
7809 if (val & DF_1_TRANS)
7810 {
7811 printf (" TRANS");
7812 val ^= DF_1_TRANS;
7813 }
7814 if (val & DF_1_INTERPOSE)
7815 {
7816 printf (" INTERPOSE");
7817 val ^= DF_1_INTERPOSE;
7818 }
f7db6139 7819 if (val & DF_1_NODEFLIB)
dcefbbbd 7820 {
f7db6139
L		 7821 printf (" NODEFLIB");
7822 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7823 }
7824 if (val & DF_1_NODUMP)
7825 {
7826 printf (" NODUMP");
7827 val ^= DF_1_NODUMP;
7828 }
7829 if (val & DF_1_CONLFAT)
7830 {
7831 printf (" CONLFAT");
7832 val ^= DF_1_CONLFAT;
7833 }
252b5132
RH		 7834 if (val != 0)
7835 printf (" %lx", val);
7836 puts ("");
7837 }
7838 }
7839 break;
7840
7841 case DT_PLTREL:
566b0d53 7842 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7843 if (do_dynamic)
7844 puts (get_dynamic_type (entry->d_un.d_val));
7845 break;
7846
7847 case DT_NULL :
7848 case DT_NEEDED :
7849 case DT_PLTGOT :
7850 case DT_HASH :
7851 case DT_STRTAB :
7852 case DT_SYMTAB :
7853 case DT_RELA :
7854 case DT_INIT :
7855 case DT_FINI :
7856 case DT_SONAME :
7857 case DT_RPATH :
7858 case DT_SYMBOLIC:
7859 case DT_REL :
7860 case DT_DEBUG :
7861 case DT_TEXTREL :
7862 case DT_JMPREL :
019148e4 7863 case DT_RUNPATH :
252b5132
RH		 7864 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7865
7866 if (do_dynamic)
7867 {
2cf0635d 7868 char * name;
252b5132 7869
d79b3d50
NC		 7870 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7871 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7872 else
d79b3d50 7873 name = NULL;
252b5132
RH		 7874
7875 if (name)
7876 {
7877 switch (entry->d_tag)
7878 {
7879 case DT_NEEDED:
7880 printf (_("Shared library: [%s]"), name);
7881
18bd398b 7882 if (streq (name, program_interpreter))
f7a99963 7883 printf (_(" program interpreter"));
252b5132
RH		 7884 break;
7885
7886 case DT_SONAME:
f7a99963 7887 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7888 break;
7889
7890 case DT_RPATH:
f7a99963 7891 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7892 break;
7893
019148e4
L		 7894 case DT_RUNPATH:
7895 printf (_("Library runpath: [%s]"), name);
7896 break;
7897
252b5132 7898 default:
f7a99963
NC		 7899 print_vma (entry->d_un.d_val, PREFIX_HEX);
7900 break;
252b5132
RH		 7901 }
7902 }
7903 else
f7a99963
NC		 7904 print_vma (entry->d_un.d_val, PREFIX_HEX);
7905
7906 putchar ('\n');
252b5132
RH		 7907 }
7908 break;
7909
7910 case DT_PLTRELSZ:
7911 case DT_RELASZ :
7912 case DT_STRSZ :
7913 case DT_RELSZ :
7914 case DT_RELAENT :
7915 case DT_SYMENT :
7916 case DT_RELENT :
566b0d53 7917 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7918 case DT_PLTPADSZ:
7919 case DT_MOVEENT :
7920 case DT_MOVESZ :
7921 case DT_INIT_ARRAYSZ:
7922 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7923 case DT_GNU_CONFLICTSZ:
7924 case DT_GNU_LIBLISTSZ:
252b5132 7925 if (do_dynamic)
f7a99963
NC		 7926 {
7927 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7928 printf (_(" (bytes)\n"));
f7a99963 7929 }
252b5132
RH		 7930 break;
7931
7932 case DT_VERDEFNUM:
7933 case DT_VERNEEDNUM:
7934 case DT_RELACOUNT:
7935 case DT_RELCOUNT:
7936 if (do_dynamic)
f7a99963
NC		 7937 {
7938 print_vma (entry->d_un.d_val, UNSIGNED);
7939 putchar ('\n');
7940 }
252b5132
RH		 7941 break;
7942
7943 case DT_SYMINSZ:
7944 case DT_SYMINENT:
7945 case DT_SYMINFO:
7946 case DT_USED:
7947 case DT_INIT_ARRAY:
7948 case DT_FINI_ARRAY:
7949 if (do_dynamic)
7950 {
d79b3d50
NC		 7951 if (entry->d_tag == DT_USED
7952 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7953 {
2cf0635d 7954 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7955
b34976b6 7956 if (*name)
252b5132
RH		 7957 {
7958 printf (_("Not needed object: [%s]\n"), name);
7959 break;
7960 }
7961 }
103f02d3 7962
f7a99963
NC		 7963 print_vma (entry->d_un.d_val, PREFIX_HEX);
7964 putchar ('\n');
252b5132
RH		 7965 }
7966 break;
7967
7968 case DT_BIND_NOW:
7969 /* The value of this entry is ignored. */
35b1837e
AM		 7970 if (do_dynamic)
7971 putchar ('\n');
252b5132 7972 break;
103f02d3 7973
047b2264
JJ		 7974 case DT_GNU_PRELINKED:
7975 if (do_dynamic)
7976 {
2cf0635d 7977 struct tm * tmp;
91d6fa6a 7978 time_t atime = entry->d_un.d_val;
047b2264 7979
91d6fa6a 7980 tmp = gmtime (&atime);
047b2264
JJ		 7981 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7982 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7983 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7984
7985 }
7986 break;
7987
fdc90cb4
JJ		 7988 case DT_GNU_HASH:
7989 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7990 if (do_dynamic)
7991 {
7992 print_vma (entry->d_un.d_val, PREFIX_HEX);
7993 putchar ('\n');
7994 }
7995 break;
7996
252b5132
RH		 7997 default:
7998 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 7999 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8000 entry->d_un.d_val;
8001
8002 if (do_dynamic)
8003 {
8004 switch (elf_header.e_machine)
8005 {
8006 case EM_MIPS:
4fe85591 8007 case EM_MIPS_RS3_LE:
b2d38a17 8008 dynamic_section_mips_val (entry);
252b5132 8009 break;
103f02d3 8010 case EM_PARISC:
b2d38a17 8011 dynamic_section_parisc_val (entry);
103f02d3 8012 break;
ecc51f48 8013 case EM_IA_64:
b2d38a17 8014 dynamic_section_ia64_val (entry);
ecc51f48 8015 break;
252b5132 8016 default:
f7a99963
NC		 8017 print_vma (entry->d_un.d_val, PREFIX_HEX);
8018 putchar ('\n');
252b5132
RH		 8019 }
8020 }
8021 break;
8022 }
8023 }
8024
8025 return 1;
8026}
8027
8028static char *
d3ba0551 8029get_ver_flags (unsigned int flags)
252b5132 8030{
b34976b6 8031 static char buff[32];
252b5132
RH		 8032
8033 buff[0] = 0;
8034
8035 if (flags == 0)
8036 return _("none");
8037
8038 if (flags & VER_FLG_BASE)
8039 strcat (buff, "BASE ");
8040
8041 if (flags & VER_FLG_WEAK)
8042 {
8043 if (flags & VER_FLG_BASE)
8044 strcat (buff, "| ");
8045
8046 strcat (buff, "WEAK ");
8047 }
8048
44ec90b9
RO		 8049 if (flags & VER_FLG_INFO)
8050 {
8051 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8052 strcat (buff, "| ");
8053
8054 strcat (buff, "INFO ");
8055 }
8056
8057 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8058 strcat (buff, _("| <unknown>"));
252b5132
RH		 8059
8060 return buff;
8061}
8062
8063/* Display the contents of the version sections. */
98fb390a 8064
252b5132 8065static int
2cf0635d 8066process_version_sections (FILE * file)
252b5132 8067{
2cf0635d 8068 Elf_Internal_Shdr * section;
b34976b6
AM		 8069 unsigned i;
8070 int found = 0;
252b5132
RH		 8071
8072 if (! do_version)
8073 return 1;
8074
8075 for (i = 0, section = section_headers;
8076 i < elf_header.e_shnum;
b34976b6 8077 i++, section++)
252b5132
RH		 8078 {
8079 switch (section->sh_type)
8080 {
8081 case SHT_GNU_verdef:
8082 {
2cf0635d 8083 Elf_External_Verdef * edefs;
b34976b6
AM		 8084 unsigned int idx;
8085 unsigned int cnt;
2cf0635d 8086 char * endbuf;
252b5132
RH		 8087
8088 found = 1;
8089
8090 printf
72de5009 8091 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8092 SECTION_NAME (section), section->sh_info);
8093
8094 printf (_(" Addr: 0x"));
8095 printf_vma (section->sh_addr);
72de5009 8096 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8097 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8098 section->sh_link < elf_header.e_shnum
8099 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8100 : _("<corrupt>"));
252b5132 8101
3f5e193b
NC		 8102 edefs = (Elf_External_Verdef *)
8103 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8104 _("version definition section"));
a6e9f9df
AM		 8105 if (!edefs)
8106 break;
59245841 8107 endbuf = (char *) edefs + section->sh_size;
252b5132 8108
b34976b6 8109 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8110 {
2cf0635d
NC		 8111 char * vstart;
8112 Elf_External_Verdef * edef;
b34976b6 8113 Elf_Internal_Verdef ent;
2cf0635d 8114 Elf_External_Verdaux * eaux;
b34976b6
AM		 8115 Elf_Internal_Verdaux aux;
8116 int j;
8117 int isum;
103f02d3 8118
dd24e3da
NC		 8119 /* Check for negative or very large indicies. */
8120 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8121 break;
8122
252b5132 8123 vstart = ((char *) edefs) + idx;
54806181
AM		 8124 if (vstart + sizeof (*edef) > endbuf)
8125 break;
252b5132
RH		 8126
8127 edef = (Elf_External_Verdef *) vstart;
8128
8129 ent.vd_version = BYTE_GET (edef->vd_version);
8130 ent.vd_flags = BYTE_GET (edef->vd_flags);
8131 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8132 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8133 ent.vd_hash = BYTE_GET (edef->vd_hash);
8134 ent.vd_aux = BYTE_GET (edef->vd_aux);
8135 ent.vd_next = BYTE_GET (edef->vd_next);
8136
8137 printf (_(" %#06x: Rev: %d Flags: %s"),
8138 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8139
8140 printf (_(" Index: %d Cnt: %d "),
8141 ent.vd_ndx, ent.vd_cnt);
8142
dd24e3da
NC		 8143 /* Check for overflow. */
8144 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8145 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8146 break;
8147
252b5132
RH		 8148 vstart += ent.vd_aux;
8149
8150 eaux = (Elf_External_Verdaux *) vstart;
8151
8152 aux.vda_name = BYTE_GET (eaux->vda_name);
8153 aux.vda_next = BYTE_GET (eaux->vda_next);
8154
d79b3d50
NC		 8155 if (VALID_DYNAMIC_NAME (aux.vda_name))
8156 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8157 else
8158 printf (_("Name index: %ld\n"), aux.vda_name);
8159
8160 isum = idx + ent.vd_aux;
8161
b34976b6 8162 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8163 {
dd24e3da
NC		 8164 /* Check for overflow. */
8165 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8166 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8167 break;
8168
252b5132
RH		 8169 isum += aux.vda_next;
8170 vstart += aux.vda_next;
8171
8172 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8173 if (vstart + sizeof (*eaux) > endbuf)
8174 break;
252b5132
RH		 8175
8176 aux.vda_name = BYTE_GET (eaux->vda_name);
8177 aux.vda_next = BYTE_GET (eaux->vda_next);
8178
d79b3d50 8179 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8180 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8181 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8182 else
8183 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8184 isum, j, aux.vda_name);
8185 }
dd24e3da 8186
54806181
AM		 8187 if (j < ent.vd_cnt)
8188 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8189
8190 idx += ent.vd_next;
8191 }
dd24e3da 8192
54806181
AM		 8193 if (cnt < section->sh_info)
8194 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8195
8196 free (edefs);
8197 }
8198 break;
103f02d3 8199
252b5132
RH		 8200 case SHT_GNU_verneed:
8201 {
2cf0635d 8202 Elf_External_Verneed * eneed;
b34976b6
AM		 8203 unsigned int idx;
8204 unsigned int cnt;
2cf0635d 8205 char * endbuf;
252b5132
RH		 8206
8207 found = 1;
8208
72de5009 8209 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8210 SECTION_NAME (section), section->sh_info);
8211
8212 printf (_(" Addr: 0x"));
8213 printf_vma (section->sh_addr);
72de5009 8214 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8215 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8216 section->sh_link < elf_header.e_shnum
8217 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8218 : _("<corrupt>"));
252b5132 8219
3f5e193b
NC		 8220 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8221 section->sh_offset, 1,
8222 section->sh_size,
8223 _("version need section"));
a6e9f9df
AM		 8224 if (!eneed)
8225 break;
59245841 8226 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8227
8228 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8229 {
2cf0635d 8230 Elf_External_Verneed * entry;
b34976b6
AM		 8231 Elf_Internal_Verneed ent;
8232 int j;
8233 int isum;
2cf0635d 8234 char * vstart;
252b5132 8235
dd24e3da
NC		 8236 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8237 break;
8238
252b5132 8239 vstart = ((char *) eneed) + idx;
54806181
AM		 8240 if (vstart + sizeof (*entry) > endbuf)
8241 break;
252b5132
RH		 8242
8243 entry = (Elf_External_Verneed *) vstart;
8244
8245 ent.vn_version = BYTE_GET (entry->vn_version);
8246 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8247 ent.vn_file = BYTE_GET (entry->vn_file);
8248 ent.vn_aux = BYTE_GET (entry->vn_aux);
8249 ent.vn_next = BYTE_GET (entry->vn_next);
8250
8251 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8252
d79b3d50
NC		 8253 if (VALID_DYNAMIC_NAME (ent.vn_file))
8254 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8255 else
8256 printf (_(" File: %lx"), ent.vn_file);
8257
8258 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8259
dd24e3da
NC		 8260 /* Check for overflow. */
8261 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8262 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8263 break;
8264
252b5132
RH		 8265 vstart += ent.vn_aux;
8266
8267 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8268 {
2cf0635d 8269 Elf_External_Vernaux * eaux;
b34976b6 8270 Elf_Internal_Vernaux aux;
252b5132 8271
54806181
AM		 8272 if (vstart + sizeof (*eaux) > endbuf)
8273 break;
252b5132
RH		 8274 eaux = (Elf_External_Vernaux *) vstart;
8275
8276 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8277 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8278 aux.vna_other = BYTE_GET (eaux->vna_other);
8279 aux.vna_name = BYTE_GET (eaux->vna_name);
8280 aux.vna_next = BYTE_GET (eaux->vna_next);
8281
d79b3d50 8282 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8283 printf (_(" %#06x: Name: %s"),
d79b3d50 8284 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8285 else
ecc2063b 8286 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8287 isum, aux.vna_name);
8288
8289 printf (_(" Flags: %s Version: %d\n"),
8290 get_ver_flags (aux.vna_flags), aux.vna_other);
8291
dd24e3da
NC		 8292 /* Check for overflow. */
8293 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8294 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8295 break;
8296
252b5132
RH		 8297 isum += aux.vna_next;
8298 vstart += aux.vna_next;
8299 }
54806181
AM		 8300 if (j < ent.vn_cnt)
8301 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 8302
8303 idx += ent.vn_next;
8304 }
54806181
AM		 8305 if (cnt < section->sh_info)
8306 printf (_(" Version need past end of section\n"));
103f02d3 8307
252b5132
RH		 8308 free (eneed);
8309 }
8310 break;
8311
8312 case SHT_GNU_versym:
8313 {
2cf0635d 8314 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8315 int total;
8316 int cnt;
2cf0635d
NC		 8317 unsigned char * edata;
8318 unsigned short * data;
8319 char * strtab;
8320 Elf_Internal_Sym * symbols;
8321 Elf_Internal_Shdr * string_sec;
d3ba0551 8322 long off;
252b5132 8323
4fbb74a6 8324 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8325 break;
8326
4fbb74a6 8327 link_section = section_headers + section->sh_link;
08d8fa11 8328 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8329
4fbb74a6 8330 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8331 break;
8332
252b5132
RH		 8333 found = 1;
8334
9ad5cbcf 8335 symbols = GET_ELF_SYMBOLS (file, link_section);
dd24e3da
NC		 8336 if (symbols == NULL)
8337 break;
252b5132 8338
4fbb74a6 8339 string_sec = section_headers + link_section->sh_link;
252b5132 8340
3f5e193b
NC		 8341 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8342 string_sec->sh_size,
8343 _("version string table"));
a6e9f9df 8344 if (!strtab)
0429c154
MS		 8345 {
8346 free (symbols);
8347 break;
8348 }
252b5132
RH		 8349
8350 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8351 SECTION_NAME (section), total);
8352
8353 printf (_(" Addr: "));
8354 printf_vma (section->sh_addr);
72de5009 8355 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8356 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8357 SECTION_NAME (link_section));
8358
d3ba0551
AM		 8359 off = offset_from_vma (file,
8360 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8361 total * sizeof (short));
3f5e193b
NC		 8362 edata = (unsigned char *) get_data (NULL, file, off, total,
8363 sizeof (short),
8364 _("version symbol data"));
a6e9f9df
AM		 8365 if (!edata)
8366 {
8367 free (strtab);
0429c154 8368 free (symbols);
a6e9f9df
AM		 8369 break;
8370 }
252b5132 8371
3f5e193b 8372 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8373
8374 for (cnt = total; cnt --;)
b34976b6
AM		 8375 data[cnt] = byte_get (edata + cnt * sizeof (short),
8376 sizeof (short));
252b5132
RH		 8377
8378 free (edata);
8379
8380 for (cnt = 0; cnt < total; cnt += 4)
8381 {
8382 int j, nn;
00d93f34 8383 int check_def, check_need;
2cf0635d 8384 char * name;
252b5132
RH		 8385
8386 printf (" %03x:", cnt);
8387
8388 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8389 switch (data[cnt + j])
252b5132
RH		 8390 {
8391 case 0:
8392 fputs (_(" 0 (*local*) "), stdout);
8393 break;
8394
8395 case 1:
8396 fputs (_(" 1 (*global*) "), stdout);
8397 break;
8398
8399 default:
c244d050
NC		 8400 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8401 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8402
dd24e3da
NC		 8403 /* If this index value is greater than the size of the symbols
8404 array, break to avoid an out-of-bounds read, */
8405 if ((unsigned long)(cnt + j) >=
8406 ((unsigned long)link_section->sh_size /
8407 (unsigned long)link_section->sh_entsize))
8408 {
8409 warn (_("invalid index into symbol array\n"));
8410 break;
8411 }
8412
00d93f34
JJ		 8413 check_def = 1;
8414 check_need = 1;
4fbb74a6
AM		 8415 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8416 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8417 != SHT_NOBITS)
252b5132 8418 {
b34976b6 8419 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8420 check_def = 0;
8421 else
8422 check_need = 0;
252b5132 8423 }
00d93f34
JJ		 8424
8425 if (check_need
b34976b6 8426 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8427 {
b34976b6
AM		 8428 Elf_Internal_Verneed ivn;
8429 unsigned long offset;
252b5132 8430
d93f0186
NC		 8431 offset = offset_from_vma
8432 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8433 sizeof (Elf_External_Verneed));
252b5132 8434
b34976b6 8435 do
252b5132 8436 {
b34976b6
AM		 8437 Elf_Internal_Vernaux ivna;
8438 Elf_External_Verneed evn;
8439 Elf_External_Vernaux evna;
8440 unsigned long a_off;
252b5132 8441
59245841
NC		 8442 if (get_data (&evn, file, offset, sizeof (evn), 1,
8443 _("version need")) == NULL)
8444 break;
8445
252b5132
RH		 8446 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8447 ivn.vn_next = BYTE_GET (evn.vn_next);
8448
8449 a_off = offset + ivn.vn_aux;
8450
8451 do
8452 {
59245841
NC		 8453 if (get_data (&evna, file, a_off, sizeof (evna),
8454 1, _("version need aux (2)")) == NULL)
8455 {
8456 ivna.vna_next = 0;
8457 ivna.vna_other = 0;
8458 }
8459 else
8460 {
8461 ivna.vna_next = BYTE_GET (evna.vna_next);
8462 ivna.vna_other = BYTE_GET (evna.vna_other);
8463 }
252b5132
RH		 8464
8465 a_off += ivna.vna_next;
8466 }
b34976b6 8467 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8468 && ivna.vna_next != 0);
8469
b34976b6 8470 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8471 {
8472 ivna.vna_name = BYTE_GET (evna.vna_name);
8473
54806181
AM		 8474 if (ivna.vna_name >= string_sec->sh_size)
8475 name = _("*invalid*");
8476 else
8477 name = strtab + ivna.vna_name;
252b5132 8478 nn += printf ("(%s%-*s",
16062207
ILT		 8479 name,
8480 12 - (int) strlen (name),
252b5132 8481 ")");
00d93f34 8482 check_def = 0;
252b5132
RH		 8483 break;
8484 }
8485
8486 offset += ivn.vn_next;
8487 }
8488 while (ivn.vn_next);
8489 }
00d93f34 8490
b34976b6
AM		 8491 if (check_def && data[cnt + j] != 0x8001
8492 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8493 {
b34976b6
AM		 8494 Elf_Internal_Verdef ivd;
8495 Elf_External_Verdef evd;
8496 unsigned long offset;
252b5132 8497
d93f0186
NC		 8498 offset = offset_from_vma
8499 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8500 sizeof evd);
252b5132
RH		 8501
8502 do
8503 {
59245841
NC		 8504 if (get_data (&evd, file, offset, sizeof (evd), 1,
8505 _("version def")) == NULL)
8506 {
8507 ivd.vd_next = 0;
8508 ivd.vd_ndx = 0;
8509 }
8510 else
8511 {
8512 ivd.vd_next = BYTE_GET (evd.vd_next);
8513 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8514 }
252b5132
RH		 8515
8516 offset += ivd.vd_next;
8517 }
c244d050 8518 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8519 && ivd.vd_next != 0);
8520
c244d050 8521 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8522 {
b34976b6
AM		 8523 Elf_External_Verdaux evda;
8524 Elf_Internal_Verdaux ivda;
252b5132
RH		 8525
8526 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8527
59245841
NC		 8528 if (get_data (&evda, file,
8529 offset - ivd.vd_next + ivd.vd_aux,
8530 sizeof (evda), 1,
8531 _("version def aux")) == NULL)
8532 break;
252b5132
RH		 8533
8534 ivda.vda_name = BYTE_GET (evda.vda_name);
8535
54806181
AM		 8536 if (ivda.vda_name >= string_sec->sh_size)
8537 name = _("*invalid*");
8538 else
8539 name = strtab + ivda.vda_name;
252b5132 8540 nn += printf ("(%s%-*s",
16062207
ILT		 8541 name,
8542 12 - (int) strlen (name),
252b5132
RH		 8543 ")");
8544 }
8545 }
8546
8547 if (nn < 18)
8548 printf ("%*c", 18 - nn, ' ');
8549 }
8550
8551 putchar ('\n');
8552 }
8553
8554 free (data);
8555 free (strtab);
8556 free (symbols);
8557 }
8558 break;
103f02d3 8559
252b5132
RH		 8560 default:
8561 break;
8562 }
8563 }
8564
8565 if (! found)
8566 printf (_("\nNo version information found in this file.\n"));
8567
8568 return 1;
8569}
8570
d1133906 8571static const char *
d3ba0551 8572get_symbol_binding (unsigned int binding)
252b5132 8573{
b34976b6 8574 static char buff[32];
252b5132
RH		 8575
8576 switch (binding)
8577 {
b34976b6
AM		 8578 case STB_LOCAL: return "LOCAL";
8579 case STB_GLOBAL: return "GLOBAL";
8580 case STB_WEAK: return "WEAK";
252b5132
RH		 8581 default:
8582 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8583 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8584 binding);
252b5132 8585 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8586 {
8587 if (binding == STB_GNU_UNIQUE
8588 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8589 /* GNU/Linux is still using the default value 0. */
8590 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8591 return "UNIQUE";
8592 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8593 }
252b5132 8594 else
e9e44622 8595 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8596 return buff;
8597 }
8598}
8599
d1133906 8600static const char *
d3ba0551 8601get_symbol_type (unsigned int type)
252b5132 8602{
b34976b6 8603 static char buff[32];
252b5132
RH		 8604
8605 switch (type)
8606 {
b34976b6
AM		 8607 case STT_NOTYPE: return "NOTYPE";
8608 case STT_OBJECT: return "OBJECT";
8609 case STT_FUNC: return "FUNC";
8610 case STT_SECTION: return "SECTION";
8611 case STT_FILE: return "FILE";
8612 case STT_COMMON: return "COMMON";
8613 case STT_TLS: return "TLS";
15ab5209
DB		 8614 case STT_RELC: return "RELC";
8615 case STT_SRELC: return "SRELC";
252b5132
RH		 8616 default:
8617 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8618 {
8619 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8620 return "THUMB_FUNC";
8621
351b4b40 8622 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8623 return "REGISTER";
8624
8625 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8626 return "PARISC_MILLI";
8627
e9e44622 8628 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8629 }
252b5132 8630 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8631 {
8632 if (elf_header.e_machine == EM_PARISC)
8633 {
8634 if (type == STT_HP_OPAQUE)
8635 return "HP_OPAQUE";
8636 if (type == STT_HP_STUB)
8637 return "HP_STUB";
8638 }
8639
d8045f23
NC		 8640 if (type == STT_GNU_IFUNC
8641 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8642 /* GNU/Linux is still using the default value 0. */
8643 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8644 return "IFUNC";
8645
e9e44622 8646 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8647 }
252b5132 8648 else
e9e44622 8649 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8650 return buff;
8651 }
8652}
8653
d1133906 8654static const char *
d3ba0551 8655get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8656{
8657 switch (visibility)
8658 {
b34976b6
AM		 8659 case STV_DEFAULT: return "DEFAULT";
8660 case STV_INTERNAL: return "INTERNAL";
8661 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8662 case STV_PROTECTED: return "PROTECTED";
8663 default: abort ();
8664 }
8665}
8666
5e2b0d47
NC		 8667static const char *
8668get_mips_symbol_other (unsigned int other)
8669{
8670 switch (other)
8671 {
8672 case STO_OPTIONAL: return "OPTIONAL";
8673 case STO_MIPS16: return "MIPS16";
861fb55a
DJ		 8674 case STO_MIPS_PLT: return "MIPS PLT";
8675 case STO_MIPS_PIC: return "MIPS PIC";
5e2b0d47
NC		 8676 default: return NULL;
8677 }
8678}
8679
28f997cf
TG		 8680static const char *
8681get_ia64_symbol_other (unsigned int other)
8682{
8683 if (is_ia64_vms ())
8684 {
8685 static char res[32];
8686
8687 res[0] = 0;
8688
8689 /* Function types is for images and .STB files only. */
8690 switch (elf_header.e_type)
8691 {
8692 case ET_DYN:
8693 case ET_EXEC:
8694 switch (VMS_ST_FUNC_TYPE (other))
8695 {
8696 case VMS_SFT_CODE_ADDR:
8697 strcat (res, " CA");
8698 break;
8699 case VMS_SFT_SYMV_IDX:
8700 strcat (res, " VEC");
8701 break;
8702 case VMS_SFT_FD:
8703 strcat (res, " FD");
8704 break;
8705 case VMS_SFT_RESERVE:
8706 strcat (res, " RSV");
8707 break;
8708 default:
8709 abort ();
8710 }
8711 break;
8712 default:
8713 break;
8714 }
8715 switch (VMS_ST_LINKAGE (other))
8716 {
8717 case VMS_STL_IGNORE:
8718 strcat (res, " IGN");
8719 break;
8720 case VMS_STL_RESERVE:
8721 strcat (res, " RSV");
8722 break;
8723 case VMS_STL_STD:
8724 strcat (res, " STD");
8725 break;
8726 case VMS_STL_LNK:
8727 strcat (res, " LNK");
8728 break;
8729 default:
8730 abort ();
8731 }
8732
8733 if (res[0] != 0)
8734 return res + 1;
8735 else
8736 return res;
8737 }
8738 return NULL;
8739}
8740
5e2b0d47
NC		 8741static const char *
8742get_symbol_other (unsigned int other)
8743{
8744 const char * result = NULL;
8745 static char buff [32];
8746
8747 if (other == 0)
8748 return "";
8749
8750 switch (elf_header.e_machine)
8751 {
8752 case EM_MIPS:
8753 result = get_mips_symbol_other (other);
28f997cf
TG		 8754 break;
8755 case EM_IA_64:
8756 result = get_ia64_symbol_other (other);
8757 break;
5e2b0d47
NC		 8758 default:
8759 break;
8760 }
8761
8762 if (result)
8763 return result;
8764
8765 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8766 return buff;
8767}
8768
d1133906 8769static const char *
d3ba0551 8770get_symbol_index_type (unsigned int type)
252b5132 8771{
b34976b6 8772 static char buff[32];
5cf1065c 8773
252b5132
RH		 8774 switch (type)
8775 {
b34976b6
AM		 8776 case SHN_UNDEF: return "UND";
8777 case SHN_ABS: return "ABS";
8778 case SHN_COMMON: return "COM";
252b5132 8779 default:
9ce701e2
L		 8780 if (type == SHN_IA_64_ANSI_COMMON
8781 && elf_header.e_machine == EM_IA_64
8782 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8783 return "ANSI_COM";
8a9036a4
L		 8784 else if ((elf_header.e_machine == EM_X86_64
8785 || elf_header.e_machine == EM_L1OM)
3b22753a
L		 8786 && type == SHN_X86_64_LCOMMON)
8787 return "LARGE_COM";
ac145307
BS		 8788 else if ((type == SHN_MIPS_SCOMMON
8789 && elf_header.e_machine == EM_MIPS)
8790 || (type == SHN_TIC6X_SCOMMON
8791 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8792 return "SCOM";
8793 else if (type == SHN_MIPS_SUNDEFINED
8794 && elf_header.e_machine == EM_MIPS)
8795 return "SUND";
9ce701e2 8796 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8797 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8798 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8799 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8800 else if (type >= SHN_LORESERVE)
8801 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8802 else
232e7cb8 8803 sprintf (buff, "%3d", type);
5cf1065c 8804 break;
252b5132 8805 }
5cf1065c
NC		 8806
8807 return buff;
252b5132
RH		 8808}
8809
66543521 8810static bfd_vma *
2cf0635d 8811get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8812{
2cf0635d
NC		 8813 unsigned char * e_data;
8814 bfd_vma * i_data;
252b5132 8815
3f5e193b 8816 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8817
8818 if (e_data == NULL)
8819 {
8820 error (_("Out of memory\n"));
8821 return NULL;
8822 }
8823
66543521 8824 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8825 {
8826 error (_("Unable to read in dynamic data\n"));
8827 return NULL;
8828 }
8829
3f5e193b 8830 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8831
8832 if (i_data == NULL)
8833 {
8834 error (_("Out of memory\n"));
8835 free (e_data);
8836 return NULL;
8837 }
8838
8839 while (number--)
66543521 8840 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8841
8842 free (e_data);
8843
8844 return i_data;
8845}
8846
6bd1a22c
L		 8847static void
8848print_dynamic_symbol (bfd_vma si, unsigned long hn)
8849{
2cf0635d 8850 Elf_Internal_Sym * psym;
6bd1a22c
L		 8851 int n;
8852
8853 psym = dynamic_symbols + si;
8854
8855 n = print_vma (si, DEC_5);
8856 if (n < 5)
8857 fputs (" " + n, stdout);
8858 printf (" %3lu: ", hn);
8859 print_vma (psym->st_value, LONG_HEX);
8860 putchar (' ');
8861 print_vma (psym->st_size, DEC_5);
8862
f4be36b3
AM		 8863 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8864 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8865 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8866 /* Check to see if any other bits in the st_other field are set.
8867 Note - displaying this information disrupts the layout of the
8868 table being generated, but for the moment this case is very
8869 rare. */
8870 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8871 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8872 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8873 if (VALID_DYNAMIC_NAME (psym->st_name))
8874 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8875 else
2b692964 8876 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8877 putchar ('\n');
8878}
8879
e3c8793a 8880/* Dump the symbol table. */
252b5132 8881static int
2cf0635d 8882process_symbol_table (FILE * file)
252b5132 8883{
2cf0635d 8884 Elf_Internal_Shdr * section;
66543521
AM		 8885 bfd_vma nbuckets = 0;
8886 bfd_vma nchains = 0;
2cf0635d
NC		 8887 bfd_vma * buckets = NULL;
8888 bfd_vma * chains = NULL;
fdc90cb4 8889 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8890 bfd_vma * gnubuckets = NULL;
8891 bfd_vma * gnuchains = NULL;
6bd1a22c 8892 bfd_vma gnusymidx = 0;
252b5132 8893
2c610e4b 8894 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8895 return 1;
8896
6bd1a22c
L		 8897 if (dynamic_info[DT_HASH]
8898 && (do_histogram
2c610e4b
L		 8899 || (do_using_dynamic
8900 && !do_dyn_syms
8901 && dynamic_strings != NULL)))
252b5132 8902 {
66543521
AM		 8903 unsigned char nb[8];
8904 unsigned char nc[8];
8905 int hash_ent_size = 4;
8906
8907 if ((elf_header.e_machine == EM_ALPHA
8908 || elf_header.e_machine == EM_S390
8909 || elf_header.e_machine == EM_S390_OLD)
8910 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8911 hash_ent_size = 8;
8912
fb52b2f4
NC		 8913 if (fseek (file,
8914 (archive_file_offset
8915 + offset_from_vma (file, dynamic_info[DT_HASH],
8916 sizeof nb + sizeof nc)),
d93f0186 8917 SEEK_SET))
252b5132 8918 {
591a748a 8919 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8920 goto no_hash;
252b5132
RH		 8921 }
8922
66543521 8923 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8924 {
8925 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8926 goto no_hash;
252b5132
RH		 8927 }
8928
66543521 8929 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8930 {
8931 error (_("Failed to read in number of chains\n"));
d3a44ec6 8932 goto no_hash;
252b5132
RH		 8933 }
8934
66543521
AM		 8935 nbuckets = byte_get (nb, hash_ent_size);
8936 nchains = byte_get (nc, hash_ent_size);
252b5132 8937
66543521
AM		 8938 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8939 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8940
d3a44ec6 8941 no_hash:
252b5132 8942 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8943 {
8944 if (do_using_dynamic)
8945 return 0;
8946 free (buckets);
8947 free (chains);
8948 buckets = NULL;
8949 chains = NULL;
8950 nbuckets = 0;
8951 nchains = 0;
8952 }
252b5132
RH		 8953 }
8954
6bd1a22c
L		 8955 if (dynamic_info_DT_GNU_HASH
8956 && (do_histogram
2c610e4b
L		 8957 || (do_using_dynamic
8958 && !do_dyn_syms
8959 && dynamic_strings != NULL)))
252b5132 8960 {
6bd1a22c
L		 8961 unsigned char nb[16];
8962 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8963 bfd_vma buckets_vma;
8964
8965 if (fseek (file,
8966 (archive_file_offset
8967 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8968 sizeof nb)),
8969 SEEK_SET))
8970 {
8971 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8972 goto no_gnu_hash;
6bd1a22c 8973 }
252b5132 8974
6bd1a22c
L		 8975 if (fread (nb, 16, 1, file) != 1)
8976 {
8977 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8978 goto no_gnu_hash;
6bd1a22c
L		 8979 }
8980
8981 ngnubuckets = byte_get (nb, 4);
8982 gnusymidx = byte_get (nb + 4, 4);
8983 bitmaskwords = byte_get (nb + 8, 4);
8984 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 8985 if (is_32bit_elf)
6bd1a22c 8986 buckets_vma += bitmaskwords * 4;
f7a99963 8987 else
6bd1a22c 8988 buckets_vma += bitmaskwords * 8;
252b5132 8989
6bd1a22c
L		 8990 if (fseek (file,
8991 (archive_file_offset
8992 + offset_from_vma (file, buckets_vma, 4)),
8993 SEEK_SET))
252b5132 8994 {
6bd1a22c 8995 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8996 goto no_gnu_hash;
6bd1a22c
L		 8997 }
8998
8999 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9000
6bd1a22c 9001 if (gnubuckets == NULL)
d3a44ec6 9002 goto no_gnu_hash;
6bd1a22c
L		 9003
9004 for (i = 0; i < ngnubuckets; i++)
9005 if (gnubuckets[i] != 0)
9006 {
9007 if (gnubuckets[i] < gnusymidx)
9008 return 0;
9009
9010 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9011 maxchain = gnubuckets[i];
9012 }
9013
9014 if (maxchain == 0xffffffff)
d3a44ec6 9015 goto no_gnu_hash;
6bd1a22c
L		 9016
9017 maxchain -= gnusymidx;
9018
9019 if (fseek (file,
9020 (archive_file_offset
9021 + offset_from_vma (file, buckets_vma
9022 + 4 * (ngnubuckets + maxchain), 4)),
9023 SEEK_SET))
9024 {
9025 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9026 goto no_gnu_hash;
6bd1a22c
L		 9027 }
9028
9029 do
9030 {
9031 if (fread (nb, 4, 1, file) != 1)
252b5132 9032 {
6bd1a22c 9033 error (_("Failed to determine last chain length\n"));
d3a44ec6 9034 goto no_gnu_hash;
6bd1a22c 9035 }
252b5132 9036
6bd1a22c 9037 if (maxchain + 1 == 0)
d3a44ec6 9038 goto no_gnu_hash;
252b5132 9039
6bd1a22c
L		 9040 ++maxchain;
9041 }
9042 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9043
6bd1a22c
L		 9044 if (fseek (file,
9045 (archive_file_offset
9046 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9047 SEEK_SET))
9048 {
9049 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9050 goto no_gnu_hash;
6bd1a22c
L		 9051 }
9052
9053 gnuchains = get_dynamic_data (file, maxchain, 4);
9054
d3a44ec6 9055 no_gnu_hash:
6bd1a22c 9056 if (gnuchains == NULL)
d3a44ec6
JJ		 9057 {
9058 free (gnubuckets);
d3a44ec6
JJ		 9059 gnubuckets = NULL;
9060 ngnubuckets = 0;
f64fddf1
NC		 9061 if (do_using_dynamic)
9062 return 0;
d3a44ec6 9063 }
6bd1a22c
L		 9064 }
9065
9066 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9067 && do_syms
9068 && do_using_dynamic
9069 && dynamic_strings != NULL)
9070 {
9071 unsigned long hn;
9072
9073 if (dynamic_info[DT_HASH])
9074 {
9075 bfd_vma si;
9076
9077 printf (_("\nSymbol table for image:\n"));
9078 if (is_32bit_elf)
9079 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9080 else
9081 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9082
9083 for (hn = 0; hn < nbuckets; hn++)
9084 {
9085 if (! buckets[hn])
9086 continue;
9087
9088 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9089 print_dynamic_symbol (si, hn);
252b5132
RH		 9090 }
9091 }
6bd1a22c
L		 9092
9093 if (dynamic_info_DT_GNU_HASH)
9094 {
9095 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9096 if (is_32bit_elf)
9097 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9098 else
9099 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9100
9101 for (hn = 0; hn < ngnubuckets; ++hn)
9102 if (gnubuckets[hn] != 0)
9103 {
9104 bfd_vma si = gnubuckets[hn];
9105 bfd_vma off = si - gnusymidx;
9106
9107 do
9108 {
9109 print_dynamic_symbol (si, hn);
9110 si++;
9111 }
9112 while ((gnuchains[off++] & 1) == 0);
9113 }
9114 }
252b5132 9115 }
2c610e4b 9116 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9117 {
b34976b6 9118 unsigned int i;
252b5132
RH		 9119
9120 for (i = 0, section = section_headers;
9121 i < elf_header.e_shnum;
9122 i++, section++)
9123 {
b34976b6 9124 unsigned int si;
2cf0635d 9125 char * strtab = NULL;
c256ffe7 9126 unsigned long int strtab_size = 0;
2cf0635d
NC		 9127 Elf_Internal_Sym * symtab;
9128 Elf_Internal_Sym * psym;
252b5132 9129
2c610e4b
L		 9130 if ((section->sh_type != SHT_SYMTAB
9131 && section->sh_type != SHT_DYNSYM)
9132 || (!do_syms
9133 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9134 continue;
9135
dd24e3da
NC		 9136 if (section->sh_entsize == 0)
9137 {
9138 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9139 SECTION_NAME (section));
9140 continue;
9141 }
9142
252b5132
RH		 9143 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9144 SECTION_NAME (section),
9145 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9146
f7a99963 9147 if (is_32bit_elf)
ca47b30c 9148 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9149 else
ca47b30c 9150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9151
9ad5cbcf 9152 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 9153 if (symtab == NULL)
9154 continue;
9155
9156 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9157 {
9158 strtab = string_table;
9159 strtab_size = string_table_length;
9160 }
4fbb74a6 9161 else if (section->sh_link < elf_header.e_shnum)
252b5132 9162 {
2cf0635d 9163 Elf_Internal_Shdr * string_sec;
252b5132 9164
4fbb74a6 9165 string_sec = section_headers + section->sh_link;
252b5132 9166
3f5e193b
NC		 9167 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9168 1, string_sec->sh_size,
9169 _("string table"));
c256ffe7 9170 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9171 }
9172
9173 for (si = 0, psym = symtab;
9174 si < section->sh_size / section->sh_entsize;
b34976b6 9175 si++, psym++)
252b5132 9176 {
5e220199 9177 printf ("%6d: ", si);
f7a99963
NC		 9178 print_vma (psym->st_value, LONG_HEX);
9179 putchar (' ');
9180 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9181 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9182 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9183 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9184 /* Check to see if any other bits in the st_other field are set.
9185 Note - displaying this information disrupts the layout of the
9186 table being generated, but for the moment this case is very rare. */
9187 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9188 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9189 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9190 print_symbol (25, psym->st_name < strtab_size
2b692964 9191 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9192
59245841
NC		 9193 if (section->sh_type == SHT_DYNSYM
9194 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9195 {
b34976b6
AM		 9196 unsigned char data[2];
9197 unsigned short vers_data;
9198 unsigned long offset;
9199 int is_nobits;
9200 int check_def;
252b5132 9201
d93f0186
NC		 9202 offset = offset_from_vma
9203 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9204 sizeof data + si * sizeof (vers_data));
252b5132 9205
59245841
NC		 9206 if (get_data (&data, file, offset + si * sizeof (vers_data),
9207 sizeof (data), 1, _("version data")) == NULL)
9208 break;
252b5132
RH		 9209
9210 vers_data = byte_get (data, 2);
9211
4fbb74a6
AM		 9212 is_nobits = (psym->st_shndx < elf_header.e_shnum
9213 && section_headers[psym->st_shndx].sh_type
c256ffe7 9214 == SHT_NOBITS);
252b5132
RH		 9215
9216 check_def = (psym->st_shndx != SHN_UNDEF);
9217
c244d050 9218 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9219 {
b34976b6 9220 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9221 && (is_nobits || ! check_def))
252b5132 9222 {
b34976b6
AM		 9223 Elf_External_Verneed evn;
9224 Elf_Internal_Verneed ivn;
9225 Elf_Internal_Vernaux ivna;
252b5132
RH		 9226
9227 /* We must test both. */
d93f0186
NC		 9228 offset = offset_from_vma
9229 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9230 sizeof evn);
252b5132 9231
252b5132
RH		 9232 do
9233 {
b34976b6 9234 unsigned long vna_off;
252b5132 9235
59245841
NC		 9236 if (get_data (&evn, file, offset, sizeof (evn), 1,
9237 _("version need")) == NULL)
9238 {
9239 ivna.vna_next = 0;
9240 ivna.vna_other = 0;
9241 ivna.vna_name = 0;
9242 break;
9243 }
dd27201e
L		 9244
9245 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9246 ivn.vn_next = BYTE_GET (evn.vn_next);
9247
252b5132
RH		 9248 vna_off = offset + ivn.vn_aux;
9249
9250 do
9251 {
b34976b6 9252 Elf_External_Vernaux evna;
252b5132 9253
59245841
NC		 9254 if (get_data (&evna, file, vna_off,
9255 sizeof (evna), 1,
9256 _("version need aux (3)")) == NULL)
9257 {
9258 ivna.vna_next = 0;
9259 ivna.vna_other = 0;
9260 ivna.vna_name = 0;
9261 }
9262 else
9263 {
9264 ivna.vna_other = BYTE_GET (evna.vna_other);
9265 ivna.vna_next = BYTE_GET (evna.vna_next);
9266 ivna.vna_name = BYTE_GET (evna.vna_name);
9267 }
252b5132
RH		 9268
9269 vna_off += ivna.vna_next;
9270 }
9271 while (ivna.vna_other != vers_data
9272 && ivna.vna_next != 0);
9273
9274 if (ivna.vna_other == vers_data)
9275 break;
9276
9277 offset += ivn.vn_next;
9278 }
9279 while (ivn.vn_next != 0);
9280
9281 if (ivna.vna_other == vers_data)
9282 {
9283 printf ("@%s (%d)",
c256ffe7 9284 ivna.vna_name < strtab_size
2b692964 9285 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9286 ivna.vna_other);
252b5132
RH		 9287 check_def = 0;
9288 }
9289 else if (! is_nobits)
591a748a 9290 error (_("bad dynamic symbol\n"));
252b5132
RH		 9291 else
9292 check_def = 1;
9293 }
9294
9295 if (check_def)
9296 {
00d93f34 9297 if (vers_data != 0x8001
b34976b6 9298 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9299 {
b34976b6
AM		 9300 Elf_Internal_Verdef ivd;
9301 Elf_Internal_Verdaux ivda;
9302 Elf_External_Verdaux evda;
91d6fa6a 9303 unsigned long off;
252b5132 9304
91d6fa6a 9305 off = offset_from_vma
d93f0186
NC		 9306 (file,
9307 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9308 sizeof (Elf_External_Verdef));
252b5132
RH		 9309
9310 do
9311 {
b34976b6 9312 Elf_External_Verdef evd;
252b5132 9313
59245841
NC		 9314 if (get_data (&evd, file, off, sizeof (evd),
9315 1, _("version def")) == NULL)
9316 {
9317 ivd.vd_ndx = 0;
9318 ivd.vd_aux = 0;
9319 ivd.vd_next = 0;
9320 }
9321 else
9322 {
9323 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9324 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9325 ivd.vd_next = BYTE_GET (evd.vd_next);
9326 }
252b5132 9327
91d6fa6a 9328 off += ivd.vd_next;
252b5132 9329 }
c244d050 9330 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9331 && ivd.vd_next != 0);
9332
91d6fa6a
NC		 9333 off -= ivd.vd_next;
9334 off += ivd.vd_aux;
252b5132 9335
59245841
NC		 9336 if (get_data (&evda, file, off, sizeof (evda),
9337 1, _("version def aux")) == NULL)
9338 break;
252b5132
RH		 9339
9340 ivda.vda_name = BYTE_GET (evda.vda_name);
9341
9342 if (psym->st_name != ivda.vda_name)
c244d050 9343 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9344 ? "@%s" : "@@%s",
c256ffe7 9345 ivda.vda_name < strtab_size
2b692964 9346 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9347 }
9348 }
9349 }
9350 }
9351
9352 putchar ('\n');
9353 }
9354
9355 free (symtab);
9356 if (strtab != string_table)
9357 free (strtab);
9358 }
9359 }
9360 else if (do_syms)
9361 printf
9362 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9363
9364 if (do_histogram && buckets != NULL)
9365 {
2cf0635d
NC		 9366 unsigned long * lengths;
9367 unsigned long * counts;
66543521
AM		 9368 unsigned long hn;
9369 bfd_vma si;
9370 unsigned long maxlength = 0;
9371 unsigned long nzero_counts = 0;
9372 unsigned long nsyms = 0;
252b5132 9373
66543521
AM		 9374 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9375 (unsigned long) nbuckets);
252b5132
RH		 9376 printf (_(" Length Number %% of total Coverage\n"));
9377
3f5e193b 9378 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9379 if (lengths == NULL)
9380 {
591a748a 9381 error (_("Out of memory\n"));
252b5132
RH		 9382 return 0;
9383 }
9384 for (hn = 0; hn < nbuckets; ++hn)
9385 {
f7a99963 9386 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9387 {
b34976b6 9388 ++nsyms;
252b5132 9389 if (maxlength < ++lengths[hn])
b34976b6 9390 ++maxlength;
252b5132
RH		 9391 }
9392 }
9393
3f5e193b 9394 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9395 if (counts == NULL)
9396 {
591a748a 9397 error (_("Out of memory\n"));
252b5132
RH		 9398 return 0;
9399 }
9400
9401 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9402 ++counts[lengths[hn]];
252b5132 9403
103f02d3 9404 if (nbuckets > 0)
252b5132 9405 {
66543521
AM		 9406 unsigned long i;
9407 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9408 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9409 for (i = 1; i <= maxlength; ++i)
103f02d3 9410 {
66543521
AM		 9411 nzero_counts += counts[i] * i;
9412 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9413 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9414 (nzero_counts * 100.0) / nsyms);
9415 }
252b5132
RH		 9416 }
9417
9418 free (counts);
9419 free (lengths);
9420 }
9421
9422 if (buckets != NULL)
9423 {
9424 free (buckets);
9425 free (chains);
9426 }
9427
d3a44ec6 9428 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9429 {
2cf0635d
NC		 9430 unsigned long * lengths;
9431 unsigned long * counts;
fdc90cb4
JJ		 9432 unsigned long hn;
9433 unsigned long maxlength = 0;
9434 unsigned long nzero_counts = 0;
9435 unsigned long nsyms = 0;
fdc90cb4 9436
3f5e193b 9437 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9438 if (lengths == NULL)
9439 {
591a748a 9440 error (_("Out of memory\n"));
fdc90cb4
JJ		 9441 return 0;
9442 }
9443
9444 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9445 (unsigned long) ngnubuckets);
9446 printf (_(" Length Number %% of total Coverage\n"));
9447
9448 for (hn = 0; hn < ngnubuckets; ++hn)
9449 if (gnubuckets[hn] != 0)
9450 {
9451 bfd_vma off, length = 1;
9452
6bd1a22c 9453 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9454 (gnuchains[off] & 1) == 0; ++off)
9455 ++length;
9456 lengths[hn] = length;
9457 if (length > maxlength)
9458 maxlength = length;
9459 nsyms += length;
9460 }
9461
3f5e193b 9462 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9463 if (counts == NULL)
9464 {
591a748a 9465 error (_("Out of memory\n"));
fdc90cb4
JJ		 9466 return 0;
9467 }
9468
9469 for (hn = 0; hn < ngnubuckets; ++hn)
9470 ++counts[lengths[hn]];
9471
9472 if (ngnubuckets > 0)
9473 {
9474 unsigned long j;
9475 printf (" 0 %-10lu (%5.1f%%)\n",
9476 counts[0], (counts[0] * 100.0) / ngnubuckets);
9477 for (j = 1; j <= maxlength; ++j)
9478 {
9479 nzero_counts += counts[j] * j;
9480 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9481 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9482 (nzero_counts * 100.0) / nsyms);
9483 }
9484 }
9485
9486 free (counts);
9487 free (lengths);
9488 free (gnubuckets);
9489 free (gnuchains);
9490 }
9491
252b5132
RH		 9492 return 1;
9493}
9494
9495static int
2cf0635d 9496process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9497{
b4c96d0d 9498 unsigned int i;
252b5132
RH		 9499
9500 if (dynamic_syminfo == NULL
9501 || !do_dynamic)
9502 /* No syminfo, this is ok. */
9503 return 1;
9504
9505 /* There better should be a dynamic symbol section. */
9506 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9507 return 0;
9508
9509 if (dynamic_addr)
9510 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9511 dynamic_syminfo_offset, dynamic_syminfo_nent);
9512
9513 printf (_(" Num: Name BoundTo Flags\n"));
9514 for (i = 0; i < dynamic_syminfo_nent; ++i)
9515 {
9516 unsigned short int flags = dynamic_syminfo[i].si_flags;
9517
31104126 9518 printf ("%4d: ", i);
d79b3d50
NC		 9519 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9520 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9521 else
2b692964 9522 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9523 putchar (' ');
252b5132
RH		 9524
9525 switch (dynamic_syminfo[i].si_boundto)
9526 {
9527 case SYMINFO_BT_SELF:
9528 fputs ("SELF ", stdout);
9529 break;
9530 case SYMINFO_BT_PARENT:
9531 fputs ("PARENT ", stdout);
9532 break;
9533 default:
9534 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9535 && dynamic_syminfo[i].si_boundto < dynamic_nent
9536 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9537 {
d79b3d50 9538 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9539 putchar (' ' );
9540 }
252b5132
RH		 9541 else
9542 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9543 break;
9544 }
9545
9546 if (flags & SYMINFO_FLG_DIRECT)
9547 printf (" DIRECT");
9548 if (flags & SYMINFO_FLG_PASSTHRU)
9549 printf (" PASSTHRU");
9550 if (flags & SYMINFO_FLG_COPY)
9551 printf (" COPY");
9552 if (flags & SYMINFO_FLG_LAZYLOAD)
9553 printf (" LAZYLOAD");
9554
9555 puts ("");
9556 }
9557
9558 return 1;
9559}
9560
cf13d699
NC		 9561/* Check to see if the given reloc needs to be handled in a target specific
9562 manner. If so then process the reloc and return TRUE otherwise return
9563 FALSE. */
09c11c86 9564
cf13d699
NC		 9565static bfd_boolean
9566target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9567 unsigned char * start,
9568 Elf_Internal_Sym * symtab)
252b5132 9569{
cf13d699 9570 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9571
cf13d699 9572 switch (elf_header.e_machine)
252b5132 9573 {
cf13d699
NC		 9574 case EM_MN10300:
9575 case EM_CYGNUS_MN10300:
9576 {
9577 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9578
cf13d699
NC		 9579 switch (reloc_type)
9580 {
9581 case 34: /* R_MN10300_ALIGN */
9582 return TRUE;
9583 case 33: /* R_MN10300_SYM_DIFF */
9584 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9585 return TRUE;
9586 case 1: /* R_MN10300_32 */
9587 case 2: /* R_MN10300_16 */
9588 if (saved_sym != NULL)
9589 {
9590 bfd_vma value;
252b5132 9591
cf13d699
NC		 9592 value = reloc->r_addend
9593 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9594 - saved_sym->st_value);
252b5132 9595
cf13d699 9596 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9597
cf13d699
NC		 9598 saved_sym = NULL;
9599 return TRUE;
9600 }
9601 break;
9602 default:
9603 if (saved_sym != NULL)
9604 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9605 break;
9606 }
9607 break;
9608 }
252b5132
RH		 9609 }
9610
cf13d699 9611 return FALSE;
252b5132
RH		 9612}
9613
aca88567
NC		 9614/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9615 DWARF debug sections. This is a target specific test. Note - we do not
9616 go through the whole including-target-headers-multiple-times route, (as
9617 we have already done with <elf/h8.h>) because this would become very
9618 messy and even then this function would have to contain target specific
9619 information (the names of the relocs instead of their numeric values).
9620 FIXME: This is not the correct way to solve this problem. The proper way
9621 is to have target specific reloc sizing and typing functions created by
9622 the reloc-macros.h header, in the same way that it already creates the
9623 reloc naming functions. */
9624
9625static bfd_boolean
9626is_32bit_abs_reloc (unsigned int reloc_type)
9627{
9628 switch (elf_header.e_machine)
9629 {
41e92641
NC		 9630 case EM_386:
9631 case EM_486:
9632 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9633 case EM_68K:
9634 return reloc_type == 1; /* R_68K_32. */
9635 case EM_860:
9636 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9637 case EM_960:
9638 return reloc_type == 2; /* R_960_32. */
aca88567 9639 case EM_ALPHA:
137b6b5f 9640 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9641 case EM_ARC:
9642 return reloc_type == 1; /* R_ARC_32. */
9643 case EM_ARM:
9644 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9645 case EM_AVR_OLD:
aca88567
NC		 9646 case EM_AVR:
9647 return reloc_type == 1;
9648 case EM_BLACKFIN:
9649 return reloc_type == 0x12; /* R_byte4_data. */
9650 case EM_CRIS:
9651 return reloc_type == 3; /* R_CRIS_32. */
9652 case EM_CR16:
6c03b1ed 9653 case EM_CR16_OLD:
aca88567
NC		 9654 return reloc_type == 3; /* R_CR16_NUM32. */
9655 case EM_CRX:
9656 return reloc_type == 15; /* R_CRX_NUM32. */
9657 case EM_CYGNUS_FRV:
9658 return reloc_type == 1;
41e92641
NC		 9659 case EM_CYGNUS_D10V:
9660 case EM_D10V:
9661 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9662 case EM_CYGNUS_D30V:
9663 case EM_D30V:
9664 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9665 case EM_DLX:
9666 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9667 case EM_CYGNUS_FR30:
9668 case EM_FR30:
9669 return reloc_type == 3; /* R_FR30_32. */
9670 case EM_H8S:
9671 case EM_H8_300:
9672 case EM_H8_300H:
9673 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9674 case EM_IA_64:
9675 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9676 case EM_IP2K_OLD:
9677 case EM_IP2K:
9678 return reloc_type == 2; /* R_IP2K_32. */
9679 case EM_IQ2000:
9680 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9681 case EM_LATTICEMICO32:
9682 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9683 case EM_M32C_OLD:
aca88567
NC		 9684 case EM_M32C:
9685 return reloc_type == 3; /* R_M32C_32. */
9686 case EM_M32R:
9687 return reloc_type == 34; /* R_M32R_32_RELA. */
9688 case EM_MCORE:
9689 return reloc_type == 1; /* R_MCORE_ADDR32. */
9690 case EM_CYGNUS_MEP:
9691 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9692 case EM_MICROBLAZE:
9693 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9694 case EM_MIPS:
9695 return reloc_type == 2; /* R_MIPS_32. */
9696 case EM_MMIX:
9697 return reloc_type == 4; /* R_MMIX_32. */
9698 case EM_CYGNUS_MN10200:
9699 case EM_MN10200:
9700 return reloc_type == 1; /* R_MN10200_32. */
9701 case EM_CYGNUS_MN10300:
9702 case EM_MN10300:
9703 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9704 case EM_MOXIE:
9705 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9706 case EM_MSP430_OLD:
9707 case EM_MSP430:
9708 return reloc_type == 1; /* R_MSP43_32. */
9709 case EM_MT:
9710 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9711 case EM_ALTERA_NIOS2:
9712 case EM_NIOS32:
9713 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9714 case EM_OPENRISC:
9715 case EM_OR32:
9716 return reloc_type == 1; /* R_OR32_32. */
aca88567 9717 case EM_PARISC:
5fda8eca
NC		 9718 return (reloc_type == 1 /* R_PARISC_DIR32. */
9719 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9720 case EM_PJ:
9721 case EM_PJ_OLD:
9722 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9723 case EM_PPC64:
9724 return reloc_type == 1; /* R_PPC64_ADDR32. */
9725 case EM_PPC:
9726 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9727 case EM_RX:
9728 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9729 case EM_S370:
9730 return reloc_type == 1; /* R_I370_ADDR31. */
9731 case EM_S390_OLD:
9732 case EM_S390:
9733 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9734 case EM_SCORE:
9735 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9736 case EM_SH:
9737 return reloc_type == 1; /* R_SH_DIR32. */
9738 case EM_SPARC32PLUS:
9739 case EM_SPARCV9:
9740 case EM_SPARC:
9741 return reloc_type == 3 /* R_SPARC_32. */
9742 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9743 case EM_SPU:
9744 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9745 case EM_TI_C6000:
9746 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9747 case EM_TILEGX:
9748 return reloc_type == 2; /* R_TILEGX_32. */
9749 case EM_TILEPRO:
9750 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9751 case EM_CYGNUS_V850:
9752 case EM_V850:
9753 return reloc_type == 6; /* R_V850_ABS32. */
9754 case EM_VAX:
9755 return reloc_type == 1; /* R_VAX_32. */
9756 case EM_X86_64:
8a9036a4 9757 case EM_L1OM:
aca88567 9758 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9759 case EM_XC16X:
9760 case EM_C166:
9761 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9762 case EM_XSTORMY16:
9763 return reloc_type == 1; /* R_XSTROMY16_32. */
9764 case EM_XTENSA_OLD:
9765 case EM_XTENSA:
9766 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9767 default:
9768 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9769 elf_header.e_machine);
9770 abort ();
9771 }
9772}
9773
9774/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9775 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9776
9777static bfd_boolean
9778is_32bit_pcrel_reloc (unsigned int reloc_type)
9779{
9780 switch (elf_header.e_machine)
9781 {
41e92641
NC		 9782 case EM_386:
9783 case EM_486:
3e0873ac 9784 return reloc_type == 2; /* R_386_PC32. */
aca88567 9785 case EM_68K:
3e0873ac 9786 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9787 case EM_ALPHA:
9788 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9789 case EM_ARM:
3e0873ac 9790 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9791 case EM_MICROBLAZE:
9792 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9793 case EM_PARISC:
85acf597 9794 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9795 case EM_PPC:
9796 return reloc_type == 26; /* R_PPC_REL32. */
9797 case EM_PPC64:
3e0873ac 9798 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9799 case EM_S390_OLD:
9800 case EM_S390:
3e0873ac 9801 return reloc_type == 5; /* R_390_PC32. */
aca88567 9802 case EM_SH:
3e0873ac 9803 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9804 case EM_SPARC32PLUS:
9805 case EM_SPARCV9:
9806 case EM_SPARC:
3e0873ac 9807 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9808 case EM_SPU:
9809 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9810 case EM_TILEGX:
9811 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9812 case EM_TILEPRO:
9813 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 9814 case EM_X86_64:
8a9036a4 9815 case EM_L1OM:
3e0873ac 9816 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9817 case EM_XTENSA_OLD:
9818 case EM_XTENSA:
9819 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9820 default:
9821 /* Do not abort or issue an error message here. Not all targets use
9822 pc-relative 32-bit relocs in their DWARF debug information and we
9823 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9824 more helpful warning message will be generated by apply_relocations
9825 anyway, so just return. */
aca88567
NC		 9826 return FALSE;
9827 }
9828}
9829
9830/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9831 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9832
9833static bfd_boolean
9834is_64bit_abs_reloc (unsigned int reloc_type)
9835{
9836 switch (elf_header.e_machine)
9837 {
9838 case EM_ALPHA:
9839 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9840 case EM_IA_64:
9841 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9842 case EM_PARISC:
9843 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9844 case EM_PPC64:
9845 return reloc_type == 38; /* R_PPC64_ADDR64. */
9846 case EM_SPARC32PLUS:
9847 case EM_SPARCV9:
9848 case EM_SPARC:
9849 return reloc_type == 54; /* R_SPARC_UA64. */
9850 case EM_X86_64:
8a9036a4 9851 case EM_L1OM:
aca88567 9852 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9853 case EM_S390_OLD:
9854 case EM_S390:
aa137e4d
NC		 9855 return reloc_type == 22; /* R_S390_64. */
9856 case EM_TILEGX:
9857 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 9858 case EM_MIPS:
aa137e4d 9859 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 9860 default:
9861 return FALSE;
9862 }
9863}
9864
85acf597
RH		 9865/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9866 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9867
9868static bfd_boolean
9869is_64bit_pcrel_reloc (unsigned int reloc_type)
9870{
9871 switch (elf_header.e_machine)
9872 {
9873 case EM_ALPHA:
aa137e4d 9874 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 9875 case EM_IA_64:
aa137e4d 9876 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 9877 case EM_PARISC:
aa137e4d 9878 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 9879 case EM_PPC64:
aa137e4d 9880 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 9881 case EM_SPARC32PLUS:
9882 case EM_SPARCV9:
9883 case EM_SPARC:
aa137e4d 9884 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 9885 case EM_X86_64:
8a9036a4 9886 case EM_L1OM:
aa137e4d 9887 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 9888 case EM_S390_OLD:
9889 case EM_S390:
aa137e4d
NC		 9890 return reloc_type == 23; /* R_S390_PC64. */
9891 case EM_TILEGX:
9892 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 9893 default:
9894 return FALSE;
9895 }
9896}
9897
4dc3c23d
AM		 9898/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9899 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9900
9901static bfd_boolean
9902is_24bit_abs_reloc (unsigned int reloc_type)
9903{
9904 switch (elf_header.e_machine)
9905 {
9906 case EM_CYGNUS_MN10200:
9907 case EM_MN10200:
9908 return reloc_type == 4; /* R_MN10200_24. */
9909 default:
9910 return FALSE;
9911 }
9912}
9913
aca88567
NC		 9914/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9915 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9916
9917static bfd_boolean
9918is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9919{
9920 switch (elf_header.e_machine)
9921 {
aca88567
NC		 9922 case EM_AVR_OLD:
9923 case EM_AVR:
9924 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9925 case EM_CYGNUS_D10V:
9926 case EM_D10V:
9927 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9928 case EM_H8S:
9929 case EM_H8_300:
9930 case EM_H8_300H:
aca88567
NC		 9931 return reloc_type == R_H8_DIR16;
9932 case EM_IP2K_OLD:
9933 case EM_IP2K:
9934 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9935 case EM_M32C_OLD:
f4236fe4
DD		 9936 case EM_M32C:
9937 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9938 case EM_MSP430_OLD:
9939 case EM_MSP430:
9940 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9941 case EM_ALTERA_NIOS2:
9942 case EM_NIOS32:
9943 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9944 case EM_TI_C6000:
9945 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9946 case EM_XC16X:
9947 case EM_C166:
9948 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9949 default:
aca88567 9950 return FALSE;
4b78141a
NC		 9951 }
9952}
9953
2a7b2e88
JK		 9954/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9955 relocation entries (possibly formerly used for SHT_GROUP sections). */
9956
9957static bfd_boolean
9958is_none_reloc (unsigned int reloc_type)
9959{
9960 switch (elf_header.e_machine)
9961 {
cb8f3167
NC		 9962 case EM_68K: /* R_68K_NONE. */
9963 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9964 case EM_SPARC32PLUS:
9965 case EM_SPARCV9:
cb8f3167
NC		 9966 case EM_SPARC: /* R_SPARC_NONE. */
9967 case EM_MIPS: /* R_MIPS_NONE. */
9968 case EM_PARISC: /* R_PARISC_NONE. */
9969 case EM_ALPHA: /* R_ALPHA_NONE. */
9970 case EM_PPC: /* R_PPC_NONE. */
9971 case EM_PPC64: /* R_PPC64_NONE. */
9972 case EM_ARM: /* R_ARM_NONE. */
9973 case EM_IA_64: /* R_IA64_NONE. */
9974 case EM_SH: /* R_SH_NONE. */
2a7b2e88 9975 case EM_S390_OLD:
cb8f3167
NC		 9976 case EM_S390: /* R_390_NONE. */
9977 case EM_CRIS: /* R_CRIS_NONE. */
9978 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 9979 case EM_L1OM: /* R_X86_64_NONE. */
cb8f3167 9980 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 9981 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 9982 case EM_M32R: /* R_M32R_NONE. */
40b36596 9983 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 9984 case EM_TILEGX: /* R_TILEGX_NONE. */
9985 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 9986 case EM_XC16X:
9987 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 9988 return reloc_type == 0;
58332dda
JK		 9989 case EM_XTENSA_OLD:
9990 case EM_XTENSA:
4dc3c23d
AM		 9991 return (reloc_type == 0 /* R_XTENSA_NONE. */
9992 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9993 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9994 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 9995 }
9996 return FALSE;
9997}
9998
cf13d699
NC		 9999/* Apply relocations to a section.
10000 Note: So far support has been added only for those relocations
10001 which can be found in debug sections.
10002 FIXME: Add support for more relocations ? */
1b315056 10003
cf13d699
NC		 10004static void
10005apply_relocations (void * file,
10006 Elf_Internal_Shdr * section,
10007 unsigned char * start)
1b315056 10008{
cf13d699
NC		 10009 Elf_Internal_Shdr * relsec;
10010 unsigned char * end = start + section->sh_size;
cb8f3167 10011
cf13d699
NC		 10012 if (elf_header.e_type != ET_REL)
10013 return;
1b315056 10014
cf13d699 10015 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10016 for (relsec = section_headers;
10017 relsec < section_headers + elf_header.e_shnum;
10018 ++relsec)
252b5132 10019 {
41e92641
NC		 10020 bfd_boolean is_rela;
10021 unsigned long num_relocs;
2cf0635d
NC		 10022 Elf_Internal_Rela * relocs;
10023 Elf_Internal_Rela * rp;
10024 Elf_Internal_Shdr * symsec;
10025 Elf_Internal_Sym * symtab;
10026 Elf_Internal_Sym * sym;
252b5132 10027
41e92641 10028 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10029 || relsec->sh_info >= elf_header.e_shnum
10030 || section_headers + relsec->sh_info != section
c256ffe7 10031 || relsec->sh_size == 0
4fbb74a6 10032 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10033 continue;
428409d5 10034
41e92641
NC		 10035 is_rela = relsec->sh_type == SHT_RELA;
10036
10037 if (is_rela)
10038 {
3f5e193b
NC		 10039 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10040 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10041 return;
10042 }
10043 else
10044 {
3f5e193b
NC		 10045 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10046 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10047 return;
10048 }
10049
10050 /* SH uses RELA but uses in place value instead of the addend field. */
10051 if (elf_header.e_machine == EM_SH)
10052 is_rela = FALSE;
428409d5 10053
4fbb74a6 10054 symsec = section_headers + relsec->sh_link;
3f5e193b 10055 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 10056
41e92641 10057 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10058 {
41e92641
NC		 10059 bfd_vma addend;
10060 unsigned int reloc_type;
10061 unsigned int reloc_size;
91d6fa6a 10062 unsigned char * rloc;
4b78141a 10063
aca88567 10064 reloc_type = get_reloc_type (rp->r_info);
41e92641 10065
98fb390a 10066 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10067 continue;
98fb390a
NC		 10068 else if (is_none_reloc (reloc_type))
10069 continue;
10070 else if (is_32bit_abs_reloc (reloc_type)
10071 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10072 reloc_size = 4;
85acf597
RH		 10073 else if (is_64bit_abs_reloc (reloc_type)
10074 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10075 reloc_size = 8;
4dc3c23d
AM		 10076 else if (is_24bit_abs_reloc (reloc_type))
10077 reloc_size = 3;
aca88567
NC		 10078 else if (is_16bit_abs_reloc (reloc_type))
10079 reloc_size = 2;
10080 else
4b78141a 10081 {
41e92641 10082 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10083 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10084 continue;
10085 }
103f02d3 10086
91d6fa6a
NC		 10087 rloc = start + rp->r_offset;
10088 if ((rloc + reloc_size) > end)
700dd8b7
L		 10089 {
10090 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10091 (unsigned long) rp->r_offset,
10092 SECTION_NAME (section));
10093 continue;
10094 }
103f02d3 10095
41e92641
NC		 10096 sym = symtab + get_reloc_symindex (rp->r_info);
10097
10098 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10099 make sure that it is of an appropriate type.
10100
10101 Relocations against symbols without type can happen.
10102 Gcc -feliminate-dwarf2-dups may generate symbols
10103 without type for debug info.
10104
10105 Icc generates relocations against function symbols
10106 instead of local labels.
10107
10108 Relocations against object symbols can happen, eg when
10109 referencing a global array. For an example of this see
10110 the _clz.o binary in libgcc.a. */
aca88567 10111 if (sym != symtab
55f25fc3 10112 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10113 {
41e92641 10114 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10115 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10116 (long int)(rp - relocs),
41e92641 10117 SECTION_NAME (relsec));
aca88567 10118 continue;
5b18a4bc 10119 }
252b5132 10120
4dc3c23d
AM		 10121 addend = 0;
10122 if (is_rela)
10123 addend += rp->r_addend;
c47320c3
AM		 10124 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10125 partial_inplace. */
4dc3c23d
AM		 10126 if (!is_rela
10127 || (elf_header.e_machine == EM_XTENSA
10128 && reloc_type == 1)
10129 || ((elf_header.e_machine == EM_PJ
10130 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10131 && reloc_type == 1)
10132 || ((elf_header.e_machine == EM_D30V
10133 || elf_header.e_machine == EM_CYGNUS_D30V)
10134 && reloc_type == 12))
91d6fa6a 10135 addend += byte_get (rloc, reloc_size);
cb8f3167 10136
85acf597
RH		 10137 if (is_32bit_pcrel_reloc (reloc_type)
10138 || is_64bit_pcrel_reloc (reloc_type))
10139 {
10140 /* On HPPA, all pc-relative relocations are biased by 8. */
10141 if (elf_header.e_machine == EM_PARISC)
10142 addend -= 8;
91d6fa6a 10143 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10144 reloc_size);
10145 }
41e92641 10146 else
91d6fa6a 10147 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10148 }
252b5132 10149
5b18a4bc 10150 free (symtab);
41e92641 10151 free (relocs);
5b18a4bc
NC		 10152 break;
10153 }
5b18a4bc 10154}
103f02d3 10155
cf13d699
NC		 10156#ifdef SUPPORT_DISASSEMBLY
10157static int
10158disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10159{
10160 printf (_("\nAssembly dump of section %s\n"),
10161 SECTION_NAME (section));
10162
10163 /* XXX -- to be done --- XXX */
10164
10165 return 1;
10166}
10167#endif
10168
10169/* Reads in the contents of SECTION from FILE, returning a pointer
10170 to a malloc'ed buffer or NULL if something went wrong. */
10171
10172static char *
10173get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10174{
10175 bfd_size_type num_bytes;
10176
10177 num_bytes = section->sh_size;
10178
10179 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10180 {
10181 printf (_("\nSection '%s' has no data to dump.\n"),
10182 SECTION_NAME (section));
10183 return NULL;
10184 }
10185
3f5e193b
NC		 10186 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10187 _("section contents"));
cf13d699
NC		 10188}
10189
dd24e3da 10190
cf13d699
NC		 10191static void
10192dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10193{
10194 Elf_Internal_Shdr * relsec;
10195 bfd_size_type num_bytes;
cf13d699
NC		 10196 char * data;
10197 char * end;
10198 char * start;
10199 char * name = SECTION_NAME (section);
10200 bfd_boolean some_strings_shown;
10201
10202 start = get_section_contents (section, file);
10203 if (start == NULL)
10204 return;
10205
10206 printf (_("\nString dump of section '%s':\n"), name);
10207
10208 /* If the section being dumped has relocations against it the user might
10209 be expecting these relocations to have been applied. Check for this
10210 case and issue a warning message in order to avoid confusion.
10211 FIXME: Maybe we ought to have an option that dumps a section with
10212 relocs applied ? */
10213 for (relsec = section_headers;
10214 relsec < section_headers + elf_header.e_shnum;
10215 ++relsec)
10216 {
10217 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10218 || relsec->sh_info >= elf_header.e_shnum
10219 || section_headers + relsec->sh_info != section
10220 || relsec->sh_size == 0
10221 || relsec->sh_link >= elf_header.e_shnum)
10222 continue;
10223
10224 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10225 break;
10226 }
10227
10228 num_bytes = section->sh_size;
cf13d699
NC		 10229 data = start;
10230 end = start + num_bytes;
10231 some_strings_shown = FALSE;
10232
10233 while (data < end)
10234 {
10235 while (!ISPRINT (* data))
10236 if (++ data >= end)
10237 break;
10238
10239 if (data < end)
10240 {
10241#ifndef __MSVCRT__
c975cc98
NC		 10242 /* PR 11128: Use two separate invocations in order to work
10243 around bugs in the Solaris 8 implementation of printf. */
10244 printf (" [%6tx] ", data - start);
10245 printf ("%s\n", data);
cf13d699
NC		 10246#else
10247 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10248#endif
10249 data += strlen (data);
10250 some_strings_shown = TRUE;
10251 }
10252 }
10253
10254 if (! some_strings_shown)
10255 printf (_(" No strings found in this section."));
10256
10257 free (start);
10258
10259 putchar ('\n');
10260}
10261
10262static void
10263dump_section_as_bytes (Elf_Internal_Shdr * section,
10264 FILE * file,
10265 bfd_boolean relocate)
10266{
10267 Elf_Internal_Shdr * relsec;
10268 bfd_size_type bytes;
10269 bfd_vma addr;
10270 unsigned char * data;
10271 unsigned char * start;
10272
10273 start = (unsigned char *) get_section_contents (section, file);
10274 if (start == NULL)
10275 return;
10276
10277 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10278
10279 if (relocate)
10280 {
10281 apply_relocations (file, section, start);
10282 }
10283 else
10284 {
10285 /* If the section being dumped has relocations against it the user might
10286 be expecting these relocations to have been applied. Check for this
10287 case and issue a warning message in order to avoid confusion.
10288 FIXME: Maybe we ought to have an option that dumps a section with
10289 relocs applied ? */
10290 for (relsec = section_headers;
10291 relsec < section_headers + elf_header.e_shnum;
10292 ++relsec)
10293 {
10294 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10295 || relsec->sh_info >= elf_header.e_shnum
10296 || section_headers + relsec->sh_info != section
10297 || relsec->sh_size == 0
10298 || relsec->sh_link >= elf_header.e_shnum)
10299 continue;
10300
10301 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10302 break;
10303 }
10304 }
10305
10306 addr = section->sh_addr;
10307 bytes = section->sh_size;
10308 data = start;
10309
10310 while (bytes)
10311 {
10312 int j;
10313 int k;
10314 int lbytes;
10315
10316 lbytes = (bytes > 16 ? 16 : bytes);
10317
10318 printf (" 0x%8.8lx ", (unsigned long) addr);
10319
10320 for (j = 0; j < 16; j++)
10321 {
10322 if (j < lbytes)
10323 printf ("%2.2x", data[j]);
10324 else
10325 printf (" ");
10326
10327 if ((j & 3) == 3)
10328 printf (" ");
10329 }
10330
10331 for (j = 0; j < lbytes; j++)
10332 {
10333 k = data[j];
10334 if (k >= ' ' && k < 0x7f)
10335 printf ("%c", k);
10336 else
10337 printf (".");
10338 }
10339
10340 putchar ('\n');
10341
10342 data += lbytes;
10343 addr += lbytes;
10344 bytes -= lbytes;
10345 }
10346
10347 free (start);
10348
10349 putchar ('\n');
10350}
10351
4a114e3e 10352/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10353
10354static int
d3dbc530
AM		 10355uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10356 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10357{
10358#ifndef HAVE_ZLIB_H
cf13d699
NC		 10359 return FALSE;
10360#else
10361 dwarf_size_type compressed_size = *size;
10362 unsigned char * compressed_buffer = *buffer;
10363 dwarf_size_type uncompressed_size;
10364 unsigned char * uncompressed_buffer;
10365 z_stream strm;
10366 int rc;
10367 dwarf_size_type header_size = 12;
10368
10369 /* Read the zlib header. In this case, it should be "ZLIB" followed
10370 by the uncompressed section size, 8 bytes in big-endian order. */
10371 if (compressed_size < header_size
10372 || ! streq ((char *) compressed_buffer, "ZLIB"))
10373 return 0;
10374
10375 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10376 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10377 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10378 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10379 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10380 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10381 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10382 uncompressed_size += compressed_buffer[11];
10383
10384 /* It is possible the section consists of several compressed
10385 buffers concatenated together, so we uncompress in a loop. */
10386 strm.zalloc = NULL;
10387 strm.zfree = NULL;
10388 strm.opaque = NULL;
10389 strm.avail_in = compressed_size - header_size;
10390 strm.next_in = (Bytef *) compressed_buffer + header_size;
10391 strm.avail_out = uncompressed_size;
3f5e193b 10392 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10393
10394 rc = inflateInit (& strm);
10395 while (strm.avail_in > 0)
10396 {
10397 if (rc != Z_OK)
10398 goto fail;
10399 strm.next_out = ((Bytef *) uncompressed_buffer
10400 + (uncompressed_size - strm.avail_out));
10401 rc = inflate (&strm, Z_FINISH);
10402 if (rc != Z_STREAM_END)
10403 goto fail;
10404 rc = inflateReset (& strm);
10405 }
10406 rc = inflateEnd (& strm);
10407 if (rc != Z_OK
10408 || strm.avail_out != 0)
10409 goto fail;
10410
10411 free (compressed_buffer);
10412 *buffer = uncompressed_buffer;
10413 *size = uncompressed_size;
10414 return 1;
10415
10416 fail:
10417 free (uncompressed_buffer);
4a114e3e
L		 10418 /* Indicate decompression failure. */
10419 *buffer = NULL;
cf13d699
NC		 10420 return 0;
10421#endif /* HAVE_ZLIB_H */
10422}
10423
d966045b
DJ		 10424static int
10425load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10426 Elf_Internal_Shdr * sec, void * file)
1007acb3 10427{
2cf0635d 10428 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10429 char buf [64];
1007acb3 10430
19e6b90e
L		 10431 /* If it is already loaded, do nothing. */
10432 if (section->start != NULL)
10433 return 1;
1007acb3 10434
19e6b90e
L		 10435 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10436 section->address = sec->sh_addr;
3f5e193b
NC		 10437 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10438 sec->sh_offset, 1,
10439 sec->sh_size, buf);
59245841
NC		 10440 if (section->start == NULL)
10441 section->size = 0;
10442 else
10443 {
10444 section->size = sec->sh_size;
10445 if (uncompress_section_contents (&section->start, &section->size))
10446 sec->sh_size = section->size;
10447 }
4a114e3e 10448
1b315056
CS		 10449 if (section->start == NULL)
10450 return 0;
10451
19e6b90e 10452 if (debug_displays [debug].relocate)
3f5e193b 10453 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10454
1b315056 10455 return 1;
1007acb3
L		 10456}
10457
d966045b 10458int
2cf0635d 10459load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10460{
2cf0635d
NC		 10461 struct dwarf_section * section = &debug_displays [debug].section;
10462 Elf_Internal_Shdr * sec;
d966045b
DJ		 10463
10464 /* Locate the debug section. */
10465 sec = find_section (section->uncompressed_name);
10466 if (sec != NULL)
10467 section->name = section->uncompressed_name;
10468 else
10469 {
10470 sec = find_section (section->compressed_name);
10471 if (sec != NULL)
10472 section->name = section->compressed_name;
10473 }
10474 if (sec == NULL)
10475 return 0;
10476
3f5e193b 10477 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10478}
10479
19e6b90e
L		 10480void
10481free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10482{
2cf0635d 10483 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10484
19e6b90e
L		 10485 if (section->start == NULL)
10486 return;
1007acb3 10487
19e6b90e
L		 10488 free ((char *) section->start);
10489 section->start = NULL;
10490 section->address = 0;
10491 section->size = 0;
1007acb3
L		 10492}
10493
1007acb3 10494static int
2cf0635d 10495display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10496{
2cf0635d 10497 char * name = SECTION_NAME (section);
19e6b90e
L		 10498 bfd_size_type length;
10499 int result = 1;
3f5e193b 10500 int i;
1007acb3 10501
19e6b90e
L		 10502 length = section->sh_size;
10503 if (length == 0)
1007acb3 10504 {
19e6b90e
L		 10505 printf (_("\nSection '%s' has no debugging data.\n"), name);
10506 return 0;
1007acb3 10507 }
5dff79d8
NC		 10508 if (section->sh_type == SHT_NOBITS)
10509 {
10510 /* There is no point in dumping the contents of a debugging section
10511 which has the NOBITS type - the bits in the file will be random.
10512 This can happen when a file containing a .eh_frame section is
10513 stripped with the --only-keep-debug command line option. */
10514 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10515 return 0;
10516 }
1007acb3 10517
0112cd26 10518 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10519 name = ".debug_info";
1007acb3 10520
19e6b90e
L		 10521 /* See if we know how to display the contents of this section. */
10522 for (i = 0; i < max; i++)
1b315056
CS		 10523 if (streq (debug_displays[i].section.uncompressed_name, name)
10524 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10525 {
2cf0635d 10526 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10527 int secondary = (section != find_section (name));
10528
10529 if (secondary)
3f5e193b 10530 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10531
2b6f5997 10532 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10533 sec->name = sec->uncompressed_name;
10534 else
10535 sec->name = sec->compressed_name;
3f5e193b
NC		 10536 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10537 section, file))
19e6b90e
L		 10538 {
10539 result &= debug_displays[i].display (sec, file);
1007acb3 10540
d966045b 10541 if (secondary || (i != info && i != abbrev))
3f5e193b 10542 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10543 }
1007acb3 10544
19e6b90e
L		 10545 break;
10546 }
1007acb3 10547
19e6b90e 10548 if (i == max)
1007acb3 10549 {
19e6b90e
L		 10550 printf (_("Unrecognized debug section: %s\n"), name);
10551 result = 0;
1007acb3
L		 10552 }
10553
19e6b90e 10554 return result;
5b18a4bc 10555}
103f02d3 10556
aef1f6d0
DJ		 10557/* Set DUMP_SECTS for all sections where dumps were requested
10558 based on section name. */
10559
10560static void
10561initialise_dumps_byname (void)
10562{
2cf0635d 10563 struct dump_list_entry * cur;
aef1f6d0
DJ		 10564
10565 for (cur = dump_sects_byname; cur; cur = cur->next)
10566 {
10567 unsigned int i;
10568 int any;
10569
10570 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10571 if (streq (SECTION_NAME (section_headers + i), cur->name))
10572 {
09c11c86 10573 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10574 any = 1;
10575 }
10576
10577 if (!any)
10578 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10579 cur->name);
10580 }
10581}
10582
5b18a4bc 10583static void
2cf0635d 10584process_section_contents (FILE * file)
5b18a4bc 10585{
2cf0635d 10586 Elf_Internal_Shdr * section;
19e6b90e 10587 unsigned int i;
103f02d3 10588
19e6b90e
L		 10589 if (! do_dump)
10590 return;
103f02d3 10591
aef1f6d0
DJ		 10592 initialise_dumps_byname ();
10593
19e6b90e
L		 10594 for (i = 0, section = section_headers;
10595 i < elf_header.e_shnum && i < num_dump_sects;
10596 i++, section++)
10597 {
10598#ifdef SUPPORT_DISASSEMBLY
10599 if (dump_sects[i] & DISASS_DUMP)
10600 disassemble_section (section, file);
10601#endif
10602 if (dump_sects[i] & HEX_DUMP)
cf13d699 10603 dump_section_as_bytes (section, file, FALSE);
103f02d3 10604
cf13d699
NC		 10605 if (dump_sects[i] & RELOC_DUMP)
10606 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10607
10608 if (dump_sects[i] & STRING_DUMP)
10609 dump_section_as_strings (section, file);
cf13d699
NC		 10610
10611 if (dump_sects[i] & DEBUG_DUMP)
10612 display_debug_section (section, file);
5b18a4bc 10613 }
103f02d3 10614
19e6b90e
L		 10615 /* Check to see if the user requested a
10616 dump of a section that does not exist. */
10617 while (i++ < num_dump_sects)
10618 if (dump_sects[i])
10619 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10620}
103f02d3 10621
5b18a4bc 10622static void
19e6b90e 10623process_mips_fpe_exception (int mask)
5b18a4bc 10624{
19e6b90e
L		 10625 if (mask)
10626 {
10627 int first = 1;
10628 if (mask & OEX_FPU_INEX)
10629 fputs ("INEX", stdout), first = 0;
10630 if (mask & OEX_FPU_UFLO)
10631 printf ("%sUFLO", first ? "" : "|"), first = 0;
10632 if (mask & OEX_FPU_OFLO)
10633 printf ("%sOFLO", first ? "" : "|"), first = 0;
10634 if (mask & OEX_FPU_DIV0)
10635 printf ("%sDIV0", first ? "" : "|"), first = 0;
10636 if (mask & OEX_FPU_INVAL)
10637 printf ("%sINVAL", first ? "" : "|");
10638 }
5b18a4bc 10639 else
19e6b90e 10640 fputs ("0", stdout);
5b18a4bc 10641}
103f02d3 10642
11c1ff18
PB		 10643/* ARM EABI attributes section. */
10644typedef struct
10645{
10646 int tag;
2cf0635d 10647 const char * name;
11c1ff18
PB		 10648 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10649 int type;
2cf0635d 10650 const char ** table;
11c1ff18
PB		 10651} arm_attr_public_tag;
10652
2cf0635d 10653static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10654 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10655 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10656static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10657static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10658 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10659static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10660 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10661static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10662static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10663 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10664static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10665 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10666 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10667static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10668 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10669static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10670 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10671static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10672 {"Absolute", "PC-relative", "None"};
2cf0635d 10673static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10674 {"None", "direct", "GOT-indirect"};
2cf0635d 10675static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10676 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10677static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10678static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10679 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10680static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10681static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10682static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10683 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10684static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10685 {"Unused", "small", "int", "forced to int"};
2cf0635d 10686static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10687 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10688static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10689 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10690static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10691 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10692static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10693 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10694 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10695static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10696 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10697 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10698static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10699static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10700 {"Not Allowed", "Allowed"};
2cf0635d 10701static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10702 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10703static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10704 {"Not Allowed", "Allowed"};
10705static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10706 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10707 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10708static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10709static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10710 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10711 "TrustZone and Virtualization Extensions"};
dd24e3da 10712static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10713 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10714
10715#define LOOKUP(id, name) \
10716 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10717static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10718{
10719 {4, "CPU_raw_name", 1, NULL},
10720 {5, "CPU_name", 1, NULL},
10721 LOOKUP(6, CPU_arch),
10722 {7, "CPU_arch_profile", 0, NULL},
10723 LOOKUP(8, ARM_ISA_use),
10724 LOOKUP(9, THUMB_ISA_use),
75375b3e 10725 LOOKUP(10, FP_arch),
11c1ff18 10726 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10727 LOOKUP(12, Advanced_SIMD_arch),
10728 LOOKUP(13, PCS_config),
11c1ff18
PB		 10729 LOOKUP(14, ABI_PCS_R9_use),
10730 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10731 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10732 LOOKUP(17, ABI_PCS_GOT_use),
10733 LOOKUP(18, ABI_PCS_wchar_t),
10734 LOOKUP(19, ABI_FP_rounding),
10735 LOOKUP(20, ABI_FP_denormal),
10736 LOOKUP(21, ABI_FP_exceptions),
10737 LOOKUP(22, ABI_FP_user_exceptions),
10738 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10739 {24, "ABI_align_needed", 0, NULL},
10740 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10741 LOOKUP(26, ABI_enum_size),
10742 LOOKUP(27, ABI_HardFP_use),
10743 LOOKUP(28, ABI_VFP_args),
10744 LOOKUP(29, ABI_WMMX_args),
10745 LOOKUP(30, ABI_optimization_goals),
10746 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10747 {32, "compatibility", 0, NULL},
f5f53991 10748 LOOKUP(34, CPU_unaligned_access),
75375b3e 10749 LOOKUP(36, FP_HP_extension),
8e79c3df 10750 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10751 LOOKUP(42, MPextension_use),
10752 LOOKUP(44, DIV_use),
f5f53991
AS		 10753 {64, "nodefaults", 0, NULL},
10754 {65, "also_compatible_with", 0, NULL},
10755 LOOKUP(66, T2EE_use),
10756 {67, "conformance", 1, NULL},
10757 LOOKUP(68, Virtualization_use),
cd21e546 10758 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10759};
10760#undef LOOKUP
10761
11c1ff18 10762static unsigned char *
2cf0635d 10763display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10764{
10765 int tag;
10766 unsigned int len;
10767 int val;
2cf0635d 10768 arm_attr_public_tag * attr;
11c1ff18
PB		 10769 unsigned i;
10770 int type;
10771
10772 tag = read_uleb128 (p, &len);
10773 p += len;
10774 attr = NULL;
2cf0635d 10775 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10776 {
10777 if (arm_attr_public_tags[i].tag == tag)
10778 {
10779 attr = &arm_attr_public_tags[i];
10780 break;
10781 }
10782 }
10783
10784 if (attr)
10785 {
10786 printf (" Tag_%s: ", attr->name);
10787 switch (attr->type)
10788 {
10789 case 0:
10790 switch (tag)
10791 {
10792 case 7: /* Tag_CPU_arch_profile. */
10793 val = read_uleb128 (p, &len);
10794 p += len;
10795 switch (val)
10796 {
2b692964
NC		 10797 case 0: printf (_("None\n")); break;
10798 case 'A': printf (_("Application\n")); break;
10799 case 'R': printf (_("Realtime\n")); break;
10800 case 'M': printf (_("Microcontroller\n")); break;
10801 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10802 default: printf ("??? (%d)\n", val); break;
10803 }
10804 break;
10805
75375b3e
MGD		 10806 case 24: /* Tag_align_needed. */
10807 val = read_uleb128 (p, &len);
10808 p += len;
10809 switch (val)
10810 {
2b692964
NC		 10811 case 0: printf (_("None\n")); break;
10812 case 1: printf (_("8-byte\n")); break;
10813 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10814 case 3: printf ("??? 3\n"); break;
10815 default:
10816 if (val <= 12)
dd24e3da 10817 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10818 1 << val);
10819 else
10820 printf ("??? (%d)\n", val);
10821 break;
10822 }
10823 break;
10824
10825 case 25: /* Tag_align_preserved. */
10826 val = read_uleb128 (p, &len);
10827 p += len;
10828 switch (val)
10829 {
2b692964
NC		 10830 case 0: printf (_("None\n")); break;
10831 case 1: printf (_("8-byte, except leaf SP\n")); break;
10832 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10833 case 3: printf ("??? 3\n"); break;
10834 default:
10835 if (val <= 12)
dd24e3da 10836 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10837 1 << val);
10838 else
10839 printf ("??? (%d)\n", val);
10840 break;
10841 }
10842 break;
10843
11c1ff18
PB		 10844 case 32: /* Tag_compatibility. */
10845 val = read_uleb128 (p, &len);
10846 p += len;
2b692964 10847 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10848 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10849 break;
10850
f5f53991
AS		 10851 case 64: /* Tag_nodefaults. */
10852 p++;
2b692964 10853 printf (_("True\n"));
f5f53991
AS		 10854 break;
10855
10856 case 65: /* Tag_also_compatible_with. */
10857 val = read_uleb128 (p, &len);
10858 p += len;
10859 if (val == 6 /* Tag_CPU_arch. */)
10860 {
10861 val = read_uleb128 (p, &len);
10862 p += len;
2cf0635d 10863 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10864 printf ("??? (%d)\n", val);
10865 else
10866 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10867 }
10868 else
10869 printf ("???\n");
10870 while (*(p++) != '\0' /* NUL terminator. */);
10871 break;
10872
11c1ff18 10873 default:
2cf0635d 10874 abort ();
11c1ff18
PB		 10875 }
10876 return p;
10877
10878 case 1:
10879 case 2:
10880 type = attr->type;
10881 break;
10882
10883 default:
10884 assert (attr->type & 0x80);
10885 val = read_uleb128 (p, &len);
10886 p += len;
10887 type = attr->type & 0x7f;
10888 if (val >= type)
10889 printf ("??? (%d)\n", val);
10890 else
10891 printf ("%s\n", attr->table[val]);
10892 return p;
10893 }
10894 }
10895 else
10896 {
10897 if (tag & 1)
10898 type = 1; /* String. */
10899 else
10900 type = 2; /* uleb128. */
10901 printf (" Tag_unknown_%d: ", tag);
10902 }
10903
10904 if (type == 1)
10905 {
10906 printf ("\"%s\"\n", p);
2cf0635d 10907 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10908 }
10909 else
10910 {
10911 val = read_uleb128 (p, &len);
10912 p += len;
10913 printf ("%d (0x%x)\n", val, val);
10914 }
10915
10916 return p;
10917}
10918
104d59d1 10919static unsigned char *
60bca95a
NC		 10920display_gnu_attribute (unsigned char * p,
10921 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10922{
10923 int tag;
10924 unsigned int len;
10925 int val;
10926 int type;
10927
10928 tag = read_uleb128 (p, &len);
10929 p += len;
10930
10931 /* Tag_compatibility is the only generic GNU attribute defined at
10932 present. */
10933 if (tag == 32)
10934 {
10935 val = read_uleb128 (p, &len);
10936 p += len;
2b692964 10937 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10938 p += strlen ((char *) p) + 1;
104d59d1
JM		 10939 return p;
10940 }
10941
10942 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10943 return display_proc_gnu_attribute (p, tag);
10944
10945 if (tag & 1)
10946 type = 1; /* String. */
10947 else
10948 type = 2; /* uleb128. */
10949 printf (" Tag_unknown_%d: ", tag);
10950
10951 if (type == 1)
10952 {
10953 printf ("\"%s\"\n", p);
60bca95a 10954 p += strlen ((char *) p) + 1;
104d59d1
JM		 10955 }
10956 else
10957 {
10958 val = read_uleb128 (p, &len);
10959 p += len;
10960 printf ("%d (0x%x)\n", val, val);
10961 }
10962
10963 return p;
10964}
10965
34c8bcba 10966static unsigned char *
2cf0635d 10967display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10968{
10969 int type;
10970 unsigned int len;
10971 int val;
10972
10973 if (tag == Tag_GNU_Power_ABI_FP)
10974 {
10975 val = read_uleb128 (p, &len);
10976 p += len;
10977 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 10978
34c8bcba
JM		 10979 switch (val)
10980 {
10981 case 0:
2b692964 10982 printf (_("Hard or soft float\n"));
34c8bcba
JM		 10983 break;
10984 case 1:
2b692964 10985 printf (_("Hard float\n"));
34c8bcba
JM		 10986 break;
10987 case 2:
2b692964 10988 printf (_("Soft float\n"));
34c8bcba 10989 break;
3c7b9897 10990 case 3:
2b692964 10991 printf (_("Single-precision hard float\n"));
3c7b9897 10992 break;
34c8bcba
JM		 10993 default:
10994 printf ("??? (%d)\n", val);
10995 break;
10996 }
10997 return p;
10998 }
10999
c6e65352
DJ		 11000 if (tag == Tag_GNU_Power_ABI_Vector)
11001 {
11002 val = read_uleb128 (p, &len);
11003 p += len;
11004 printf (" Tag_GNU_Power_ABI_Vector: ");
11005 switch (val)
11006 {
11007 case 0:
2b692964 11008 printf (_("Any\n"));
c6e65352
DJ		 11009 break;
11010 case 1:
2b692964 11011 printf (_("Generic\n"));
c6e65352
DJ		 11012 break;
11013 case 2:
11014 printf ("AltiVec\n");
11015 break;
11016 case 3:
11017 printf ("SPE\n");
11018 break;
11019 default:
11020 printf ("??? (%d)\n", val);
11021 break;
11022 }
11023 return p;
11024 }
11025
f82e0623
NF		 11026 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11027 {
11028 val = read_uleb128 (p, &len);
11029 p += len;
11030 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11031 switch (val)
11032 {
11033 case 0:
2b692964 11034 printf (_("Any\n"));
f82e0623
NF		 11035 break;
11036 case 1:
11037 printf ("r3/r4\n");
11038 break;
11039 case 2:
2b692964 11040 printf (_("Memory\n"));
f82e0623
NF		 11041 break;
11042 default:
11043 printf ("??? (%d)\n", val);
11044 break;
11045 }
11046 return p;
11047 }
11048
34c8bcba
JM		 11049 if (tag & 1)
11050 type = 1; /* String. */
11051 else
11052 type = 2; /* uleb128. */
11053 printf (" Tag_unknown_%d: ", tag);
11054
11055 if (type == 1)
11056 {
11057 printf ("\"%s\"\n", p);
60bca95a 11058 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11059 }
11060 else
11061 {
11062 val = read_uleb128 (p, &len);
11063 p += len;
11064 printf ("%d (0x%x)\n", val, val);
11065 }
11066
11067 return p;
11068}
11069
2cf19d5c 11070static unsigned char *
2cf0635d 11071display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11072{
11073 int type;
11074 unsigned int len;
11075 int val;
11076
11077 if (tag == Tag_GNU_MIPS_ABI_FP)
11078 {
11079 val = read_uleb128 (p, &len);
11080 p += len;
11081 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11082
2cf19d5c
JM		 11083 switch (val)
11084 {
11085 case 0:
2b692964 11086 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11087 break;
11088 case 1:
2b692964 11089 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11090 break;
11091 case 2:
2b692964 11092 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11093 break;
11094 case 3:
2b692964 11095 printf (_("Soft float\n"));
2cf19d5c 11096 break;
42554f6a 11097 case 4:
9eeefea8 11098 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11099 break;
2cf19d5c
JM		 11100 default:
11101 printf ("??? (%d)\n", val);
11102 break;
11103 }
11104 return p;
11105 }
11106
11107 if (tag & 1)
11108 type = 1; /* String. */
11109 else
11110 type = 2; /* uleb128. */
11111 printf (" Tag_unknown_%d: ", tag);
11112
11113 if (type == 1)
11114 {
11115 printf ("\"%s\"\n", p);
60bca95a 11116 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11117 }
11118 else
11119 {
11120 val = read_uleb128 (p, &len);
11121 p += len;
11122 printf ("%d (0x%x)\n", val, val);
11123 }
11124
11125 return p;
11126}
11127
59e6276b
JM		 11128static unsigned char *
11129display_tic6x_attribute (unsigned char * p)
11130{
11131 int tag;
11132 unsigned int len;
11133 int val;
11134
11135 tag = read_uleb128 (p, &len);
11136 p += len;
11137
11138 switch (tag)
11139 {
75fa6dc1 11140 case Tag_ISA:
59e6276b
JM		 11141 val = read_uleb128 (p, &len);
11142 p += len;
75fa6dc1 11143 printf (" Tag_ISA: ");
59e6276b
JM		 11144
11145 switch (val)
11146 {
75fa6dc1 11147 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11148 printf (_("None\n"));
11149 break;
75fa6dc1 11150 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11151 printf ("C62x\n");
11152 break;
75fa6dc1 11153 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11154 printf ("C67x\n");
11155 break;
75fa6dc1 11156 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11157 printf ("C67x+\n");
11158 break;
75fa6dc1 11159 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11160 printf ("C64x\n");
11161 break;
75fa6dc1 11162 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11163 printf ("C64x+\n");
11164 break;
75fa6dc1 11165 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11166 printf ("C674x\n");
11167 break;
11168 default:
11169 printf ("??? (%d)\n", val);
11170 break;
11171 }
11172 return p;
11173
87779176
JM		 11174 case Tag_ABI_wchar_t:
11175 val = read_uleb128 (p, &len);
11176 p += len;
11177 printf (" Tag_ABI_wchar_t: ");
11178 switch (val)
11179 {
11180 case 0:
11181 printf (_("Not used\n"));
11182 break;
11183 case 1:
11184 printf (_("2 bytes\n"));
11185 break;
11186 case 2:
11187 printf (_("4 bytes\n"));
11188 break;
11189 default:
11190 printf ("??? (%d)\n", val);
11191 break;
11192 }
11193 return p;
11194
11195 case Tag_ABI_stack_align_needed:
11196 val = read_uleb128 (p, &len);
11197 p += len;
11198 printf (" Tag_ABI_stack_align_needed: ");
11199 switch (val)
11200 {
11201 case 0:
11202 printf (_("8-byte\n"));
11203 break;
11204 case 1:
11205 printf (_("16-byte\n"));
11206 break;
11207 default:
11208 printf ("??? (%d)\n", val);
11209 break;
11210 }
11211 return p;
11212
11213 case Tag_ABI_stack_align_preserved:
11214 val = read_uleb128 (p, &len);
11215 p += len;
11216 printf (" Tag_ABI_stack_align_preserved: ");
11217 switch (val)
11218 {
11219 case 0:
11220 printf (_("8-byte\n"));
11221 break;
11222 case 1:
11223 printf (_("16-byte\n"));
11224 break;
11225 default:
11226 printf ("??? (%d)\n", val);
11227 break;
11228 }
11229 return p;
11230
b5593623
JM		 11231 case Tag_ABI_DSBT:
11232 val = read_uleb128 (p, &len);
11233 p += len;
11234 printf (" Tag_ABI_DSBT: ");
11235 switch (val)
11236 {
11237 case 0:
11238 printf (_("DSBT addressing not used\n"));
11239 break;
11240 case 1:
11241 printf (_("DSBT addressing used\n"));
11242 break;
11243 default:
11244 printf ("??? (%d)\n", val);
11245 break;
11246 }
11247 return p;
11248
87779176
JM		 11249 case Tag_ABI_PID:
11250 val = read_uleb128 (p, &len);
11251 p += len;
11252 printf (" Tag_ABI_PID: ");
11253 switch (val)
11254 {
11255 case 0:
11256 printf (_("Data addressing position-dependent\n"));
11257 break;
11258 case 1:
11259 printf (_("Data addressing position-independent, GOT near DP\n"));
11260 break;
11261 case 2:
11262 printf (_("Data addressing position-independent, GOT far from DP\n"));
11263 break;
11264 default:
11265 printf ("??? (%d)\n", val);
11266 break;
11267 }
11268 return p;
11269
11270 case Tag_ABI_PIC:
11271 val = read_uleb128 (p, &len);
11272 p += len;
11273 printf (" Tag_ABI_PIC: ");
11274 switch (val)
11275 {
11276 case 0:
11277 printf (_("Code addressing position-dependent\n"));
11278 break;
11279 case 1:
11280 printf (_("Code addressing position-independent\n"));
11281 break;
11282 default:
11283 printf ("??? (%d)\n", val);
11284 break;
11285 }
11286 return p;
11287
11288 case Tag_ABI_array_object_alignment:
11289 val = read_uleb128 (p, &len);
11290 p += len;
11291 printf (" Tag_ABI_array_object_alignment: ");
11292 switch (val)
11293 {
11294 case 0:
11295 printf (_("8-byte\n"));
11296 break;
11297 case 1:
11298 printf (_("4-byte\n"));
11299 break;
11300 case 2:
11301 printf (_("16-byte\n"));
11302 break;
11303 default:
11304 printf ("??? (%d)\n", val);
11305 break;
11306 }
11307 return p;
11308
11309 case Tag_ABI_array_object_align_expected:
11310 val = read_uleb128 (p, &len);
11311 p += len;
11312 printf (" Tag_ABI_array_object_align_expected: ");
11313 switch (val)
11314 {
11315 case 0:
11316 printf (_("8-byte\n"));
11317 break;
11318 case 1:
11319 printf (_("4-byte\n"));
11320 break;
11321 case 2:
11322 printf (_("16-byte\n"));
11323 break;
11324 default:
11325 printf ("??? (%d)\n", val);
11326 break;
11327 }
11328 return p;
11329
3cbd1c06 11330 case Tag_ABI_compatibility:
59e6276b
JM		 11331 val = read_uleb128 (p, &len);
11332 p += len;
3cbd1c06 11333 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11334 printf (_("flag = %d, vendor = %s\n"), val, p);
11335 p += strlen ((char *) p) + 1;
11336 return p;
87779176
JM		 11337
11338 case Tag_ABI_conformance:
11339 printf (" Tag_ABI_conformance: ");
11340 printf ("\"%s\"\n", p);
11341 p += strlen ((char *) p) + 1;
11342 return p;
59e6276b
JM		 11343 }
11344
11345 printf (" Tag_unknown_%d: ", tag);
11346
87779176
JM		 11347 if (tag & 1)
11348 {
11349 printf ("\"%s\"\n", p);
11350 p += strlen ((char *) p) + 1;
11351 }
11352 else
11353 {
11354 val = read_uleb128 (p, &len);
11355 p += len;
11356 printf ("%d (0x%x)\n", val, val);
11357 }
59e6276b
JM		 11358
11359 return p;
11360}
11361
11c1ff18 11362static int
60bca95a
NC		 11363process_attributes (FILE * file,
11364 const char * public_name,
104d59d1 11365 unsigned int proc_type,
60bca95a
NC		 11366 unsigned char * (* display_pub_attribute) (unsigned char *),
11367 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11368{
2cf0635d
NC		 11369 Elf_Internal_Shdr * sect;
11370 unsigned char * contents;
11371 unsigned char * p;
11372 unsigned char * end;
11c1ff18
PB		 11373 bfd_vma section_len;
11374 bfd_vma len;
11375 unsigned i;
11376
11377 /* Find the section header so that we get the size. */
11378 for (i = 0, sect = section_headers;
11379 i < elf_header.e_shnum;
11380 i++, sect++)
11381 {
104d59d1 11382 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11383 continue;
11384
3f5e193b
NC		 11385 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11386 sect->sh_size, _("attributes"));
60bca95a 11387 if (contents == NULL)
11c1ff18 11388 continue;
60bca95a 11389
11c1ff18
PB		 11390 p = contents;
11391 if (*p == 'A')
11392 {
11393 len = sect->sh_size - 1;
11394 p++;
60bca95a 11395
11c1ff18
PB		 11396 while (len > 0)
11397 {
11398 int namelen;
11399 bfd_boolean public_section;
104d59d1 11400 bfd_boolean gnu_section;
11c1ff18
PB		 11401
11402 section_len = byte_get (p, 4);
11403 p += 4;
60bca95a 11404
11c1ff18
PB		 11405 if (section_len > len)
11406 {
11407 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11408 (int) section_len, (int) len);
11c1ff18
PB		 11409 section_len = len;
11410 }
60bca95a 11411
11c1ff18 11412 len -= section_len;
2b692964 11413 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11414
11415 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11416 public_section = TRUE;
11417 else
11418 public_section = FALSE;
60bca95a
NC		 11419
11420 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11421 gnu_section = TRUE;
11422 else
11423 gnu_section = FALSE;
60bca95a
NC		 11424
11425 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11426 p += namelen;
11427 section_len -= namelen + 4;
60bca95a 11428
11c1ff18
PB		 11429 while (section_len > 0)
11430 {
11431 int tag = *(p++);
11432 int val;
11433 bfd_vma size;
60bca95a 11434
11c1ff18
PB		 11435 size = byte_get (p, 4);
11436 if (size > section_len)
11437 {
11438 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11439 (int) size, (int) section_len);
11c1ff18
PB		 11440 size = section_len;
11441 }
60bca95a 11442
11c1ff18
PB		 11443 section_len -= size;
11444 end = p + size - 1;
11445 p += 4;
60bca95a 11446
11c1ff18
PB		 11447 switch (tag)
11448 {
11449 case 1:
2b692964 11450 printf (_("File Attributes\n"));
11c1ff18
PB		 11451 break;
11452 case 2:
2b692964 11453 printf (_("Section Attributes:"));
11c1ff18
PB		 11454 goto do_numlist;
11455 case 3:
2b692964 11456 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11457 do_numlist:
11458 for (;;)
11459 {
91d6fa6a 11460 unsigned int j;
60bca95a 11461
91d6fa6a
NC		 11462 val = read_uleb128 (p, &j);
11463 p += j;
11c1ff18
PB		 11464 if (val == 0)
11465 break;
11466 printf (" %d", val);
11467 }
11468 printf ("\n");
11469 break;
11470 default:
2b692964 11471 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11472 public_section = FALSE;
11473 break;
11474 }
60bca95a 11475
11c1ff18
PB		 11476 if (public_section)
11477 {
11478 while (p < end)
104d59d1
JM		 11479 p = display_pub_attribute (p);
11480 }
11481 else if (gnu_section)
11482 {
11483 while (p < end)
11484 p = display_gnu_attribute (p,
11485 display_proc_gnu_attribute);
11c1ff18
PB		 11486 }
11487 else
11488 {
11489 /* ??? Do something sensible, like dump hex. */
2b692964 11490 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11491 p = end;
11492 }
11493 }
11494 }
11495 }
11496 else
60bca95a 11497 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11498
60bca95a 11499 free (contents);
11c1ff18
PB		 11500 }
11501 return 1;
11502}
11503
104d59d1 11504static int
2cf0635d 11505process_arm_specific (FILE * file)
104d59d1
JM		 11506{
11507 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11508 display_arm_attribute, NULL);
11509}
11510
34c8bcba 11511static int
2cf0635d 11512process_power_specific (FILE * file)
34c8bcba
JM		 11513{
11514 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11515 display_power_gnu_attribute);
11516}
11517
59e6276b
JM		 11518static int
11519process_tic6x_specific (FILE * file)
11520{
11521 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11522 display_tic6x_attribute, NULL);
11523}
11524
ccb4c951
RS		 11525/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11526 Print the Address, Access and Initial fields of an entry at VMA ADDR
11527 and return the VMA of the next entry. */
11528
11529static bfd_vma
2cf0635d 11530print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11531{
11532 printf (" ");
11533 print_vma (addr, LONG_HEX);
11534 printf (" ");
11535 if (addr < pltgot + 0xfff0)
11536 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11537 else
11538 printf ("%10s", "");
11539 printf (" ");
11540 if (data == NULL)
2b692964 11541 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11542 else
11543 {
11544 bfd_vma entry;
11545
11546 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11547 print_vma (entry, LONG_HEX);
11548 }
11549 return addr + (is_32bit_elf ? 4 : 8);
11550}
11551
861fb55a
DJ		 11552/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11553 PLTGOT. Print the Address and Initial fields of an entry at VMA
11554 ADDR and return the VMA of the next entry. */
11555
11556static bfd_vma
2cf0635d 11557print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11558{
11559 printf (" ");
11560 print_vma (addr, LONG_HEX);
11561 printf (" ");
11562 if (data == NULL)
2b692964 11563 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11564 else
11565 {
11566 bfd_vma entry;
11567
11568 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11569 print_vma (entry, LONG_HEX);
11570 }
11571 return addr + (is_32bit_elf ? 4 : 8);
11572}
11573
19e6b90e 11574static int
2cf0635d 11575process_mips_specific (FILE * file)
5b18a4bc 11576{
2cf0635d 11577 Elf_Internal_Dyn * entry;
19e6b90e
L		 11578 size_t liblist_offset = 0;
11579 size_t liblistno = 0;
11580 size_t conflictsno = 0;
11581 size_t options_offset = 0;
11582 size_t conflicts_offset = 0;
861fb55a
DJ		 11583 size_t pltrelsz = 0;
11584 size_t pltrel = 0;
ccb4c951 11585 bfd_vma pltgot = 0;
861fb55a
DJ		 11586 bfd_vma mips_pltgot = 0;
11587 bfd_vma jmprel = 0;
ccb4c951
RS		 11588 bfd_vma local_gotno = 0;
11589 bfd_vma gotsym = 0;
11590 bfd_vma symtabno = 0;
103f02d3 11591
2cf19d5c
JM		 11592 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11593 display_mips_gnu_attribute);
11594
19e6b90e
L		 11595 /* We have a lot of special sections. Thanks SGI! */
11596 if (dynamic_section == NULL)
11597 /* No information available. */
11598 return 0;
252b5132 11599
b2d38a17 11600 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11601 switch (entry->d_tag)
11602 {
11603 case DT_MIPS_LIBLIST:
d93f0186
NC		 11604 liblist_offset
11605 = offset_from_vma (file, entry->d_un.d_val,
11606 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11607 break;
11608 case DT_MIPS_LIBLISTNO:
11609 liblistno = entry->d_un.d_val;
11610 break;
11611 case DT_MIPS_OPTIONS:
d93f0186 11612 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11613 break;
11614 case DT_MIPS_CONFLICT:
d93f0186
NC		 11615 conflicts_offset
11616 = offset_from_vma (file, entry->d_un.d_val,
11617 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11618 break;
11619 case DT_MIPS_CONFLICTNO:
11620 conflictsno = entry->d_un.d_val;
11621 break;
ccb4c951 11622 case DT_PLTGOT:
861fb55a
DJ		 11623 pltgot = entry->d_un.d_ptr;
11624 break;
ccb4c951
RS		 11625 case DT_MIPS_LOCAL_GOTNO:
11626 local_gotno = entry->d_un.d_val;
11627 break;
11628 case DT_MIPS_GOTSYM:
11629 gotsym = entry->d_un.d_val;
11630 break;
11631 case DT_MIPS_SYMTABNO:
11632 symtabno = entry->d_un.d_val;
11633 break;
861fb55a
DJ		 11634 case DT_MIPS_PLTGOT:
11635 mips_pltgot = entry->d_un.d_ptr;
11636 break;
11637 case DT_PLTREL:
11638 pltrel = entry->d_un.d_val;
11639 break;
11640 case DT_PLTRELSZ:
11641 pltrelsz = entry->d_un.d_val;
11642 break;
11643 case DT_JMPREL:
11644 jmprel = entry->d_un.d_ptr;
11645 break;
252b5132
RH		 11646 default:
11647 break;
11648 }
11649
11650 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11651 {
2cf0635d 11652 Elf32_External_Lib * elib;
252b5132
RH		 11653 size_t cnt;
11654
3f5e193b
NC		 11655 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11656 liblistno,
11657 sizeof (Elf32_External_Lib),
11658 _("liblist"));
a6e9f9df 11659 if (elib)
252b5132 11660 {
2b692964 11661 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11662 (unsigned long) liblistno);
2b692964 11663 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11664 stdout);
11665
11666 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11667 {
a6e9f9df 11668 Elf32_Lib liblist;
91d6fa6a 11669 time_t atime;
a6e9f9df 11670 char timebuf[20];
2cf0635d 11671 struct tm * tmp;
a6e9f9df
AM		 11672
11673 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11674 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11675 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11676 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11677 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11678
91d6fa6a 11679 tmp = gmtime (&atime);
e9e44622
JJ		 11680 snprintf (timebuf, sizeof (timebuf),
11681 "%04u-%02u-%02uT%02u:%02u:%02u",
11682 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11683 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11684
31104126 11685 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11686 if (VALID_DYNAMIC_NAME (liblist.l_name))
11687 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11688 else
2b692964 11689 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11690 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11691 liblist.l_version);
a6e9f9df
AM		 11692
11693 if (liblist.l_flags == 0)
2b692964 11694 puts (_(" NONE"));
a6e9f9df
AM		 11695 else
11696 {
11697 static const struct
252b5132 11698 {
2cf0635d 11699 const char * name;
a6e9f9df 11700 int bit;
252b5132 11701 }
a6e9f9df
AM		 11702 l_flags_vals[] =
11703 {
11704 { " EXACT_MATCH", LL_EXACT_MATCH },
11705 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11706 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11707 { " EXPORTS", LL_EXPORTS },
11708 { " DELAY_LOAD", LL_DELAY_LOAD },
11709 { " DELTA", LL_DELTA }
11710 };
11711 int flags = liblist.l_flags;
11712 size_t fcnt;
11713
60bca95a 11714 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11715 if ((flags & l_flags_vals[fcnt].bit) != 0)
11716 {
11717 fputs (l_flags_vals[fcnt].name, stdout);
11718 flags ^= l_flags_vals[fcnt].bit;
11719 }
11720 if (flags != 0)
11721 printf (" %#x", (unsigned int) flags);
252b5132 11722
a6e9f9df
AM		 11723 puts ("");
11724 }
252b5132 11725 }
252b5132 11726
a6e9f9df
AM		 11727 free (elib);
11728 }
252b5132
RH		 11729 }
11730
11731 if (options_offset != 0)
11732 {
2cf0635d
NC		 11733 Elf_External_Options * eopt;
11734 Elf_Internal_Shdr * sect = section_headers;
11735 Elf_Internal_Options * iopt;
11736 Elf_Internal_Options * option;
252b5132
RH		 11737 size_t offset;
11738 int cnt;
11739
11740 /* Find the section header so that we get the size. */
11741 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11742 ++sect;
252b5132 11743
3f5e193b
NC		 11744 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11745 sect->sh_size, _("options"));
a6e9f9df 11746 if (eopt)
252b5132 11747 {
3f5e193b
NC		 11748 iopt = (Elf_Internal_Options *)
11749 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11750 if (iopt == NULL)
11751 {
591a748a 11752 error (_("Out of memory\n"));
a6e9f9df
AM		 11753 return 0;
11754 }
76da6bbe 11755
a6e9f9df
AM		 11756 offset = cnt = 0;
11757 option = iopt;
252b5132 11758
a6e9f9df
AM		 11759 while (offset < sect->sh_size)
11760 {
2cf0635d 11761 Elf_External_Options * eoption;
252b5132 11762
a6e9f9df 11763 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11764
a6e9f9df
AM		 11765 option->kind = BYTE_GET (eoption->kind);
11766 option->size = BYTE_GET (eoption->size);
11767 option->section = BYTE_GET (eoption->section);
11768 option->info = BYTE_GET (eoption->info);
76da6bbe 11769
a6e9f9df 11770 offset += option->size;
252b5132 11771
a6e9f9df
AM		 11772 ++option;
11773 ++cnt;
11774 }
252b5132 11775
a6e9f9df
AM		 11776 printf (_("\nSection '%s' contains %d entries:\n"),
11777 SECTION_NAME (sect), cnt);
76da6bbe 11778
a6e9f9df 11779 option = iopt;
252b5132 11780
a6e9f9df 11781 while (cnt-- > 0)
252b5132 11782 {
a6e9f9df
AM		 11783 size_t len;
11784
11785 switch (option->kind)
252b5132 11786 {
a6e9f9df
AM		 11787 case ODK_NULL:
11788 /* This shouldn't happen. */
11789 printf (" NULL %d %lx", option->section, option->info);
11790 break;
11791 case ODK_REGINFO:
11792 printf (" REGINFO ");
11793 if (elf_header.e_machine == EM_MIPS)
11794 {
11795 /* 32bit form. */
2cf0635d 11796 Elf32_External_RegInfo * ereg;
b34976b6 11797 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11798
11799 ereg = (Elf32_External_RegInfo *) (option + 1);
11800 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11801 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11802 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11803 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11804 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11805 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11806
11807 printf ("GPR %08lx GP 0x%lx\n",
11808 reginfo.ri_gprmask,
11809 (unsigned long) reginfo.ri_gp_value);
11810 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11811 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11812 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11813 }
11814 else
11815 {
11816 /* 64 bit form. */
2cf0635d 11817 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11818 Elf64_Internal_RegInfo reginfo;
11819
11820 ereg = (Elf64_External_RegInfo *) (option + 1);
11821 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11822 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11823 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11824 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11825 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11826 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11827
11828 printf ("GPR %08lx GP 0x",
11829 reginfo.ri_gprmask);
11830 printf_vma (reginfo.ri_gp_value);
11831 printf ("\n");
11832
11833 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11834 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11835 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11836 }
11837 ++option;
11838 continue;
11839 case ODK_EXCEPTIONS:
11840 fputs (" EXCEPTIONS fpe_min(", stdout);
11841 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11842 fputs (") fpe_max(", stdout);
11843 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11844 fputs (")", stdout);
11845
11846 if (option->info & OEX_PAGE0)
11847 fputs (" PAGE0", stdout);
11848 if (option->info & OEX_SMM)
11849 fputs (" SMM", stdout);
11850 if (option->info & OEX_FPDBUG)
11851 fputs (" FPDBUG", stdout);
11852 if (option->info & OEX_DISMISS)
11853 fputs (" DISMISS", stdout);
11854 break;
11855 case ODK_PAD:
11856 fputs (" PAD ", stdout);
11857 if (option->info & OPAD_PREFIX)
11858 fputs (" PREFIX", stdout);
11859 if (option->info & OPAD_POSTFIX)
11860 fputs (" POSTFIX", stdout);
11861 if (option->info & OPAD_SYMBOL)
11862 fputs (" SYMBOL", stdout);
11863 break;
11864 case ODK_HWPATCH:
11865 fputs (" HWPATCH ", stdout);
11866 if (option->info & OHW_R4KEOP)
11867 fputs (" R4KEOP", stdout);
11868 if (option->info & OHW_R8KPFETCH)
11869 fputs (" R8KPFETCH", stdout);
11870 if (option->info & OHW_R5KEOP)
11871 fputs (" R5KEOP", stdout);
11872 if (option->info & OHW_R5KCVTL)
11873 fputs (" R5KCVTL", stdout);
11874 break;
11875 case ODK_FILL:
11876 fputs (" FILL ", stdout);
11877 /* XXX Print content of info word? */
11878 break;
11879 case ODK_TAGS:
11880 fputs (" TAGS ", stdout);
11881 /* XXX Print content of info word? */
11882 break;
11883 case ODK_HWAND:
11884 fputs (" HWAND ", stdout);
11885 if (option->info & OHWA0_R4KEOP_CHECKED)
11886 fputs (" R4KEOP_CHECKED", stdout);
11887 if (option->info & OHWA0_R4KEOP_CLEAN)
11888 fputs (" R4KEOP_CLEAN", stdout);
11889 break;
11890 case ODK_HWOR:
11891 fputs (" HWOR ", stdout);
11892 if (option->info & OHWA0_R4KEOP_CHECKED)
11893 fputs (" R4KEOP_CHECKED", stdout);
11894 if (option->info & OHWA0_R4KEOP_CLEAN)
11895 fputs (" R4KEOP_CLEAN", stdout);
11896 break;
11897 case ODK_GP_GROUP:
11898 printf (" GP_GROUP %#06lx self-contained %#06lx",
11899 option->info & OGP_GROUP,
11900 (option->info & OGP_SELF) >> 16);
11901 break;
11902 case ODK_IDENT:
11903 printf (" IDENT %#06lx self-contained %#06lx",
11904 option->info & OGP_GROUP,
11905 (option->info & OGP_SELF) >> 16);
11906 break;
11907 default:
11908 /* This shouldn't happen. */
11909 printf (" %3d ??? %d %lx",
11910 option->kind, option->section, option->info);
11911 break;
252b5132 11912 }
a6e9f9df 11913
2cf0635d 11914 len = sizeof (* eopt);
a6e9f9df
AM		 11915 while (len < option->size)
11916 if (((char *) option)[len] >= ' '
11917 && ((char *) option)[len] < 0x7f)
11918 printf ("%c", ((char *) option)[len++]);
11919 else
11920 printf ("\\%03o", ((char *) option)[len++]);
11921
11922 fputs ("\n", stdout);
252b5132 11923 ++option;
252b5132
RH		 11924 }
11925
a6e9f9df 11926 free (eopt);
252b5132 11927 }
252b5132
RH		 11928 }
11929
11930 if (conflicts_offset != 0 && conflictsno != 0)
11931 {
2cf0635d 11932 Elf32_Conflict * iconf;
252b5132
RH		 11933 size_t cnt;
11934
11935 if (dynamic_symbols == NULL)
11936 {
591a748a 11937 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 11938 return 0;
11939 }
11940
3f5e193b 11941 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 11942 if (iconf == NULL)
11943 {
591a748a 11944 error (_("Out of memory\n"));
252b5132
RH		 11945 return 0;
11946 }
11947
9ea033b2 11948 if (is_32bit_elf)
252b5132 11949 {
2cf0635d 11950 Elf32_External_Conflict * econf32;
a6e9f9df 11951
3f5e193b
NC		 11952 econf32 = (Elf32_External_Conflict *)
11953 get_data (NULL, file, conflicts_offset, conflictsno,
11954 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 11955 if (!econf32)
11956 return 0;
252b5132
RH		 11957
11958 for (cnt = 0; cnt < conflictsno; ++cnt)
11959 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 11960
11961 free (econf32);
252b5132
RH		 11962 }
11963 else
11964 {
2cf0635d 11965 Elf64_External_Conflict * econf64;
a6e9f9df 11966
3f5e193b
NC		 11967 econf64 = (Elf64_External_Conflict *)
11968 get_data (NULL, file, conflicts_offset, conflictsno,
11969 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 11970 if (!econf64)
11971 return 0;
252b5132
RH		 11972
11973 for (cnt = 0; cnt < conflictsno; ++cnt)
11974 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 11975
11976 free (econf64);
252b5132
RH		 11977 }
11978
c7e7ca54
NC		 11979 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11980 (unsigned long) conflictsno);
252b5132
RH		 11981 puts (_(" Num: Index Value Name"));
11982
11983 for (cnt = 0; cnt < conflictsno; ++cnt)
11984 {
2cf0635d 11985 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 11986
b34976b6 11987 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 11988 print_vma (psym->st_value, FULL_HEX);
31104126 11989 putchar (' ');
d79b3d50
NC		 11990 if (VALID_DYNAMIC_NAME (psym->st_name))
11991 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11992 else
2b692964 11993 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 11994 putchar ('\n');
252b5132
RH		 11995 }
11996
252b5132
RH		 11997 free (iconf);
11998 }
11999
ccb4c951
RS		 12000 if (pltgot != 0 && local_gotno != 0)
12001 {
91d6fa6a 12002 bfd_vma ent, local_end, global_end;
bbeee7ea 12003 size_t i, offset;
2cf0635d 12004 unsigned char * data;
bbeee7ea 12005 int addr_size;
ccb4c951 12006
91d6fa6a 12007 ent = pltgot;
ccb4c951
RS		 12008 addr_size = (is_32bit_elf ? 4 : 8);
12009 local_end = pltgot + local_gotno * addr_size;
12010 global_end = local_end + (symtabno - gotsym) * addr_size;
12011
12012 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 12013 data = (unsigned char *) get_data (NULL, file, offset,
12014 global_end - pltgot, 1, _("GOT"));
59245841
NC		 12015 if (data == NULL)
12016 return 0;
12017
ccb4c951
RS		 12018 printf (_("\nPrimary GOT:\n"));
12019 printf (_(" Canonical gp value: "));
12020 print_vma (pltgot + 0x7ff0, LONG_HEX);
12021 printf ("\n\n");
12022
12023 printf (_(" Reserved entries:\n"));
12024 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12025 addr_size * 2, _("Address"), _("Access"),
12026 addr_size * 2, _("Initial"));
91d6fa6a 12027 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12028 printf (_(" Lazy resolver\n"));
ccb4c951 12029 if (data
91d6fa6a 12030 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12031 >> (addr_size * 8 - 1)) != 0)
12032 {
91d6fa6a 12033 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12034 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12035 }
12036 printf ("\n");
12037
91d6fa6a 12038 if (ent < local_end)
ccb4c951
RS		 12039 {
12040 printf (_(" Local entries:\n"));
cc5914eb 12041 printf (" %*s %10s %*s\n",
2b692964
NC		 12042 addr_size * 2, _("Address"), _("Access"),
12043 addr_size * 2, _("Initial"));
91d6fa6a 12044 while (ent < local_end)
ccb4c951 12045 {
91d6fa6a 12046 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12047 printf ("\n");
12048 }
12049 printf ("\n");
12050 }
12051
12052 if (gotsym < symtabno)
12053 {
12054 int sym_width;
12055
12056 printf (_(" Global entries:\n"));
cc5914eb 12057 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12058 addr_size * 2, _("Address"), _("Access"),
12059 addr_size * 2, _("Initial"),
12060 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 12061 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12062 for (i = gotsym; i < symtabno; i++)
12063 {
2cf0635d 12064 Elf_Internal_Sym * psym;
ccb4c951
RS		 12065
12066 psym = dynamic_symbols + i;
91d6fa6a 12067 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12068 printf (" ");
12069 print_vma (psym->st_value, LONG_HEX);
12070 printf (" %-7s %3s ",
12071 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12072 get_symbol_index_type (psym->st_shndx));
12073 if (VALID_DYNAMIC_NAME (psym->st_name))
12074 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12075 else
2b692964 12076 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12077 printf ("\n");
12078 }
12079 printf ("\n");
12080 }
12081
12082 if (data)
12083 free (data);
12084 }
12085
861fb55a
DJ		 12086 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12087 {
91d6fa6a 12088 bfd_vma ent, end;
861fb55a
DJ		 12089 size_t offset, rel_offset;
12090 unsigned long count, i;
2cf0635d 12091 unsigned char * data;
861fb55a 12092 int addr_size, sym_width;
2cf0635d 12093 Elf_Internal_Rela * rels;
861fb55a
DJ		 12094
12095 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12096 if (pltrel == DT_RELA)
12097 {
12098 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12099 return 0;
12100 }
12101 else
12102 {
12103 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12104 return 0;
12105 }
12106
91d6fa6a 12107 ent = mips_pltgot;
861fb55a
DJ		 12108 addr_size = (is_32bit_elf ? 4 : 8);
12109 end = mips_pltgot + (2 + count) * addr_size;
12110
12111 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 12112 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12113 1, _("PLT GOT"));
59245841
NC		 12114 if (data == NULL)
12115 return 0;
12116
861fb55a
DJ		 12117 printf (_("\nPLT GOT:\n\n"));
12118 printf (_(" Reserved entries:\n"));
12119 printf (_(" %*s %*s Purpose\n"),
2b692964 12120 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12121 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12122 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12123 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12124 printf (_(" Module pointer\n"));
861fb55a
DJ		 12125 printf ("\n");
12126
12127 printf (_(" Entries:\n"));
cc5914eb 12128 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12129 addr_size * 2, _("Address"),
12130 addr_size * 2, _("Initial"),
12131 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12132 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12133 for (i = 0; i < count; i++)
12134 {
2cf0635d 12135 Elf_Internal_Sym * psym;
861fb55a
DJ		 12136
12137 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12138 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12139 printf (" ");
12140 print_vma (psym->st_value, LONG_HEX);
12141 printf (" %-7s %3s ",
12142 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12143 get_symbol_index_type (psym->st_shndx));
12144 if (VALID_DYNAMIC_NAME (psym->st_name))
12145 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12146 else
2b692964 12147 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12148 printf ("\n");
12149 }
12150 printf ("\n");
12151
12152 if (data)
12153 free (data);
12154 free (rels);
12155 }
12156
252b5132
RH		 12157 return 1;
12158}
12159
047b2264 12160static int
2cf0635d 12161process_gnu_liblist (FILE * file)
047b2264 12162{
2cf0635d
NC		 12163 Elf_Internal_Shdr * section;
12164 Elf_Internal_Shdr * string_sec;
12165 Elf32_External_Lib * elib;
12166 char * strtab;
c256ffe7 12167 size_t strtab_size;
047b2264
JJ		 12168 size_t cnt;
12169 unsigned i;
12170
12171 if (! do_arch)
12172 return 0;
12173
12174 for (i = 0, section = section_headers;
12175 i < elf_header.e_shnum;
b34976b6 12176 i++, section++)
047b2264
JJ		 12177 {
12178 switch (section->sh_type)
12179 {
12180 case SHT_GNU_LIBLIST:
4fbb74a6 12181 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12182 break;
12183
3f5e193b
NC		 12184 elib = (Elf32_External_Lib *)
12185 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12186 _("liblist"));
047b2264
JJ		 12187
12188 if (elib == NULL)
12189 break;
4fbb74a6 12190 string_sec = section_headers + section->sh_link;
047b2264 12191
3f5e193b
NC		 12192 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12193 string_sec->sh_size,
12194 _("liblist string table"));
047b2264
JJ		 12195 if (strtab == NULL
12196 || section->sh_entsize != sizeof (Elf32_External_Lib))
12197 {
12198 free (elib);
2842702f 12199 free (strtab);
047b2264
JJ		 12200 break;
12201 }
59245841 12202 strtab_size = string_sec->sh_size;
047b2264
JJ		 12203
12204 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12205 SECTION_NAME (section),
0af1713e 12206 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12207
2b692964 12208 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12209
12210 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12211 ++cnt)
12212 {
12213 Elf32_Lib liblist;
91d6fa6a 12214 time_t atime;
047b2264 12215 char timebuf[20];
2cf0635d 12216 struct tm * tmp;
047b2264
JJ		 12217
12218 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12219 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12220 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12221 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12222 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12223
91d6fa6a 12224 tmp = gmtime (&atime);
e9e44622
JJ		 12225 snprintf (timebuf, sizeof (timebuf),
12226 "%04u-%02u-%02uT%02u:%02u:%02u",
12227 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12228 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12229
12230 printf ("%3lu: ", (unsigned long) cnt);
12231 if (do_wide)
c256ffe7 12232 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12233 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12234 else
c256ffe7 12235 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12236 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12237 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12238 liblist.l_version, liblist.l_flags);
12239 }
12240
12241 free (elib);
2842702f 12242 free (strtab);
047b2264
JJ		 12243 }
12244 }
12245
12246 return 1;
12247}
12248
9437c45b 12249static const char *
d3ba0551 12250get_note_type (unsigned e_type)
779fe533
NC		 12251{
12252 static char buff[64];
103f02d3 12253
1ec5cd37
NC		 12254 if (elf_header.e_type == ET_CORE)
12255 switch (e_type)
12256 {
57346661 12257 case NT_AUXV:
1ec5cd37 12258 return _("NT_AUXV (auxiliary vector)");
57346661 12259 case NT_PRSTATUS:
1ec5cd37 12260 return _("NT_PRSTATUS (prstatus structure)");
57346661 12261 case NT_FPREGSET:
1ec5cd37 12262 return _("NT_FPREGSET (floating point registers)");
57346661 12263 case NT_PRPSINFO:
1ec5cd37 12264 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12265 case NT_TASKSTRUCT:
1ec5cd37 12266 return _("NT_TASKSTRUCT (task structure)");
57346661 12267 case NT_PRXFPREG:
1ec5cd37 12268 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12269 case NT_PPC_VMX:
12270 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12271 case NT_PPC_VSX:
12272 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12273 case NT_X86_XSTATE:
12274 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12275 case NT_S390_HIGH_GPRS:
12276 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12277 case NT_S390_TIMER:
12278 return _("NT_S390_TIMER (s390 timer register)");
12279 case NT_S390_TODCMP:
12280 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12281 case NT_S390_TODPREG:
12282 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12283 case NT_S390_CTRS:
12284 return _("NT_S390_CTRS (s390 control registers)");
12285 case NT_S390_PREFIX:
12286 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12287 case NT_ARM_VFP:
12288 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12289 case NT_PSTATUS:
1ec5cd37 12290 return _("NT_PSTATUS (pstatus structure)");
57346661 12291 case NT_FPREGS:
1ec5cd37 12292 return _("NT_FPREGS (floating point registers)");
57346661 12293 case NT_PSINFO:
1ec5cd37 12294 return _("NT_PSINFO (psinfo structure)");
57346661 12295 case NT_LWPSTATUS:
1ec5cd37 12296 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12297 case NT_LWPSINFO:
1ec5cd37 12298 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12299 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12300 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12301 default:
12302 break;
12303 }
12304 else
12305 switch (e_type)
12306 {
12307 case NT_VERSION:
12308 return _("NT_VERSION (version)");
12309 case NT_ARCH:
12310 return _("NT_ARCH (architecture)");
12311 default:
12312 break;
12313 }
12314
e9e44622 12315 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12316 return buff;
779fe533
NC		 12317}
12318
1118d252
RM		 12319static const char *
12320get_gnu_elf_note_type (unsigned e_type)
12321{
12322 static char buff[64];
12323
12324 switch (e_type)
12325 {
12326 case NT_GNU_ABI_TAG:
12327 return _("NT_GNU_ABI_TAG (ABI version tag)");
12328 case NT_GNU_HWCAP:
12329 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12330 case NT_GNU_BUILD_ID:
12331 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12332 case NT_GNU_GOLD_VERSION:
12333 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12334 default:
12335 break;
12336 }
12337
12338 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12339 return buff;
12340}
12341
664f90a3
TT		 12342static int
12343print_gnu_note (Elf_Internal_Note *pnote)
12344{
12345 switch (pnote->type)
12346 {
12347 case NT_GNU_BUILD_ID:
12348 {
12349 unsigned long i;
12350
12351 printf (_(" Build ID: "));
12352 for (i = 0; i < pnote->descsz; ++i)
12353 printf ("%02x", pnote->descdata[i] & 0xff);
12354 printf (_("\n"));
12355 }
12356 break;
12357
12358 case NT_GNU_ABI_TAG:
12359 {
12360 unsigned long os, major, minor, subminor;
12361 const char *osname;
12362
12363 os = byte_get ((unsigned char *) pnote->descdata, 4);
12364 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12365 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12366 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12367
12368 switch (os)
12369 {
12370 case GNU_ABI_TAG_LINUX:
12371 osname = "Linux";
12372 break;
12373 case GNU_ABI_TAG_HURD:
12374 osname = "Hurd";
12375 break;
12376 case GNU_ABI_TAG_SOLARIS:
12377 osname = "Solaris";
12378 break;
12379 case GNU_ABI_TAG_FREEBSD:
12380 osname = "FreeBSD";
12381 break;
12382 case GNU_ABI_TAG_NETBSD:
12383 osname = "NetBSD";
12384 break;
12385 default:
12386 osname = "Unknown";
12387 break;
12388 }
12389
12390 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12391 major, minor, subminor);
12392 }
12393 break;
12394 }
12395
12396 return 1;
12397}
12398
9437c45b 12399static const char *
d3ba0551 12400get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12401{
12402 static char buff[64];
12403
b4db1224 12404 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12405 {
12406 /* NetBSD core "procinfo" structure. */
12407 return _("NetBSD procinfo structure");
12408 }
12409
12410 /* As of Jan 2002 there are no other machine-independent notes
12411 defined for NetBSD core files. If the note type is less
12412 than the start of the machine-dependent note types, we don't
12413 understand it. */
12414
b4db1224 12415 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12416 {
e9e44622 12417 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12418 return buff;
12419 }
12420
12421 switch (elf_header.e_machine)
12422 {
12423 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12424 and PT_GETFPREGS == mach+2. */
12425
12426 case EM_OLD_ALPHA:
12427 case EM_ALPHA:
12428 case EM_SPARC:
12429 case EM_SPARC32PLUS:
12430 case EM_SPARCV9:
12431 switch (e_type)
12432 {
2b692964 12433 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12434 return _("PT_GETREGS (reg structure)");
2b692964 12435 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12436 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12437 default:
12438 break;
12439 }
12440 break;
12441
12442 /* On all other arch's, PT_GETREGS == mach+1 and
12443 PT_GETFPREGS == mach+3. */
12444 default:
12445 switch (e_type)
12446 {
2b692964 12447 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12448 return _("PT_GETREGS (reg structure)");
2b692964 12449 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12450 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12451 default:
12452 break;
12453 }
12454 }
12455
e9e44622
JJ		 12456 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12457 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12458 return buff;
12459}
12460
70616151
TT		 12461static const char *
12462get_stapsdt_note_type (unsigned e_type)
12463{
12464 static char buff[64];
12465
12466 switch (e_type)
12467 {
12468 case NT_STAPSDT:
12469 return _("NT_STAPSDT (SystemTap probe descriptors)");
12470
12471 default:
12472 break;
12473 }
12474
12475 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12476 return buff;
12477}
12478
c6a9fc58
TT		 12479static int
12480print_stapsdt_note (Elf_Internal_Note *pnote)
12481{
12482 int addr_size = is_32bit_elf ? 4 : 8;
12483 char *data = pnote->descdata;
12484 char *data_end = pnote->descdata + pnote->descsz;
12485 bfd_vma pc, base_addr, semaphore;
12486 char *provider, *probe, *arg_fmt;
12487
12488 pc = byte_get ((unsigned char *) data, addr_size);
12489 data += addr_size;
12490 base_addr = byte_get ((unsigned char *) data, addr_size);
12491 data += addr_size;
12492 semaphore = byte_get ((unsigned char *) data, addr_size);
12493 data += addr_size;
12494
12495 provider = data;
12496 data += strlen (data) + 1;
12497 probe = data;
12498 data += strlen (data) + 1;
12499 arg_fmt = data;
12500 data += strlen (data) + 1;
12501
12502 printf (_(" Provider: %s\n"), provider);
12503 printf (_(" Name: %s\n"), probe);
12504 printf (_(" Location: "));
12505 print_vma (pc, FULL_HEX);
12506 printf (_(", Base: "));
12507 print_vma (base_addr, FULL_HEX);
12508 printf (_(", Semaphore: "));
12509 print_vma (semaphore, FULL_HEX);
12510 printf (_("\n"));
12511 printf (_(" Arguments: %s\n"), arg_fmt);
12512
12513 return data == data_end;
12514}
12515
00e98fc7
TG		 12516static const char *
12517get_ia64_vms_note_type (unsigned e_type)
12518{
12519 static char buff[64];
12520
12521 switch (e_type)
12522 {
12523 case NT_VMS_MHD:
12524 return _("NT_VMS_MHD (module header)");
12525 case NT_VMS_LNM:
12526 return _("NT_VMS_LNM (language name)");
12527 case NT_VMS_SRC:
12528 return _("NT_VMS_SRC (source files)");
12529 case NT_VMS_TITLE:
12530 return _("NT_VMS_TITLE");
12531 case NT_VMS_EIDC:
12532 return _("NT_VMS_EIDC (consistency check)");
12533 case NT_VMS_FPMODE:
12534 return _("NT_VMS_FPMODE (FP mode)");
12535 case NT_VMS_LINKTIME:
12536 return _("NT_VMS_LINKTIME");
12537 case NT_VMS_IMGNAM:
12538 return _("NT_VMS_IMGNAM (image name)");
12539 case NT_VMS_IMGID:
12540 return _("NT_VMS_IMGID (image id)");
12541 case NT_VMS_LINKID:
12542 return _("NT_VMS_LINKID (link id)");
12543 case NT_VMS_IMGBID:
12544 return _("NT_VMS_IMGBID (build id)");
12545 case NT_VMS_GSTNAM:
12546 return _("NT_VMS_GSTNAM (sym table name)");
12547 case NT_VMS_ORIG_DYN:
12548 return _("NT_VMS_ORIG_DYN");
12549 case NT_VMS_PATCHTIME:
12550 return _("NT_VMS_PATCHTIME");
12551 default:
12552 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12553 return buff;
12554 }
12555}
12556
12557static int
12558print_ia64_vms_note (Elf_Internal_Note * pnote)
12559{
12560 switch (pnote->type)
12561 {
12562 case NT_VMS_MHD:
12563 if (pnote->descsz > 36)
12564 {
12565 size_t l = strlen (pnote->descdata + 34);
12566 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12567 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12568 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12569 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12570 }
12571 else
12572 printf (_(" Invalid size\n"));
12573 break;
12574 case NT_VMS_LNM:
12575 printf (_(" Language: %s\n"), pnote->descdata);
12576 break;
12577#ifdef BFD64
12578 case NT_VMS_FPMODE:
12579 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12580 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12581 break;
12582 case NT_VMS_LINKTIME:
12583 printf (_(" Link time: "));
12584 print_vms_time
12585 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12586 printf ("\n");
12587 break;
12588 case NT_VMS_PATCHTIME:
12589 printf (_(" Patch time: "));
12590 print_vms_time
12591 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12592 printf ("\n");
12593 break;
12594 case NT_VMS_ORIG_DYN:
12595 printf (_(" Major id: %u, minor id: %u\n"),
12596 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12597 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12598 printf (_(" Manip date : "));
12599 print_vms_time
12600 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12601 printf (_("\n"
12602 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12603 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12604 printf (_(" Header flags: 0x%08x\n"),
12605 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12606 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12607 break;
12608#endif
12609 case NT_VMS_IMGNAM:
12610 printf (_(" Image name: %s\n"), pnote->descdata);
12611 break;
12612 case NT_VMS_GSTNAM:
12613 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12614 break;
12615 case NT_VMS_IMGID:
12616 printf (_(" Image id: %s\n"), pnote->descdata);
12617 break;
12618 case NT_VMS_LINKID:
12619 printf (_(" Linker id: %s\n"), pnote->descdata);
12620 break;
12621 default:
12622 break;
12623 }
12624 return 1;
12625}
12626
6d118b09
NC		 12627/* Note that by the ELF standard, the name field is already null byte
12628 terminated, and namesz includes the terminating null byte.
12629 I.E. the value of namesz for the name "FSF" is 4.
12630
e3c8793a 12631 If the value of namesz is zero, there is no name present. */
779fe533 12632static int
2cf0635d 12633process_note (Elf_Internal_Note * pnote)
779fe533 12634{
2cf0635d
NC		 12635 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12636 const char * nt;
9437c45b
JT		 12637
12638 if (pnote->namesz == 0)
1ec5cd37
NC		 12639 /* If there is no note name, then use the default set of
12640 note type strings. */
12641 nt = get_note_type (pnote->type);
12642
1118d252
RM		 12643 else if (const_strneq (pnote->namedata, "GNU"))
12644 /* GNU-specific object file notes. */
12645 nt = get_gnu_elf_note_type (pnote->type);
12646
0112cd26 12647 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12648 /* NetBSD-specific core file notes. */
12649 nt = get_netbsd_elfcore_note_type (pnote->type);
12650
b15fa79e
AM		 12651 else if (strneq (pnote->namedata, "SPU/", 4))
12652 {
12653 /* SPU-specific core file notes. */
12654 nt = pnote->namedata + 4;
12655 name = "SPU";
12656 }
12657
00e98fc7
TG		 12658 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12659 /* VMS/ia64-specific file notes. */
12660 nt = get_ia64_vms_note_type (pnote->type);
12661
70616151
TT		 12662 else if (const_strneq (pnote->namedata, "stapsdt"))
12663 nt = get_stapsdt_note_type (pnote->type);
12664
9437c45b 12665 else
1ec5cd37
NC		 12666 /* Don't recognize this note name; just use the default set of
12667 note type strings. */
00e98fc7 12668 nt = get_note_type (pnote->type);
9437c45b 12669
2aee03ae 12670 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12671
12672 if (const_strneq (pnote->namedata, "IPF/VMS"))
12673 return print_ia64_vms_note (pnote);
664f90a3
TT		 12674 else if (const_strneq (pnote->namedata, "GNU"))
12675 return print_gnu_note (pnote);
c6a9fc58
TT		 12676 else if (const_strneq (pnote->namedata, "stapsdt"))
12677 return print_stapsdt_note (pnote);
00e98fc7
TG		 12678 else
12679 return 1;
779fe533
NC		 12680}
12681
6d118b09 12682
779fe533 12683static int
2cf0635d 12684process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12685{
2cf0635d
NC		 12686 Elf_External_Note * pnotes;
12687 Elf_External_Note * external;
b34976b6 12688 int res = 1;
103f02d3 12689
779fe533
NC		 12690 if (length <= 0)
12691 return 0;
103f02d3 12692
3f5e193b
NC		 12693 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12694 _("notes"));
dd24e3da 12695 if (pnotes == NULL)
a6e9f9df 12696 return 0;
779fe533 12697
103f02d3 12698 external = pnotes;
103f02d3 12699
305c7206 12700 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12701 (unsigned long) offset, (unsigned long) length);
2aee03ae 12702 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 12703
2cf0635d 12704 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12705 {
2cf0635d 12706 Elf_External_Note * next;
b34976b6 12707 Elf_Internal_Note inote;
2cf0635d 12708 char * temp = NULL;
6d118b09 12709
00e98fc7
TG		 12710 if (!is_ia64_vms ())
12711 {
12712 inote.type = BYTE_GET (external->type);
12713 inote.namesz = BYTE_GET (external->namesz);
12714 inote.namedata = external->name;
12715 inote.descsz = BYTE_GET (external->descsz);
12716 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12717 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12718
12719 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12720 }
12721 else
12722 {
12723 Elf64_External_VMS_Note *vms_external;
12724
12725 vms_external = (Elf64_External_VMS_Note *)external;
12726 inote.type = BYTE_GET (vms_external->type);
12727 inote.namesz = BYTE_GET (vms_external->namesz);
12728 inote.namedata = vms_external->name;
12729 inote.descsz = BYTE_GET (vms_external->descsz);
12730 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12731 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12732
12733 next = (Elf_External_Note *)
12734 (inote.descdata + align_power (inote.descsz, 3));
12735 }
3e55a963 12736
dd24e3da
NC		 12737 if ( ((char *) next > ((char *) pnotes) + length)
12738 || ((char *) next < (char *) pnotes))
3e55a963 12739 {
0fd3a477 12740 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12741 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12742 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12743 inote.type, inote.namesz, inote.descsz);
12744 break;
12745 }
12746
12747 external = next;
6d118b09 12748
dd24e3da
NC		 12749 /* Prevent out-of-bounds indexing. */
12750 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12751 || inote.namedata + inote.namesz < inote.namedata)
12752 {
12753 warn (_("corrupt note found at offset %lx into core notes\n"),
12754 (unsigned long) ((char *) external - (char *) pnotes));
12755 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12756 inote.type, inote.namesz, inote.descsz);
12757 break;
12758 }
12759
6d118b09
NC		 12760 /* Verify that name is null terminated. It appears that at least
12761 one version of Linux (RedHat 6.0) generates corefiles that don't
12762 comply with the ELF spec by failing to include the null byte in
12763 namesz. */
12764 if (inote.namedata[inote.namesz] != '\0')
12765 {
3f5e193b 12766 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 12767
6d118b09
NC		 12768 if (temp == NULL)
12769 {
12770 error (_("Out of memory\n"));
12771 res = 0;
12772 break;
12773 }
76da6bbe 12774
6d118b09
NC		 12775 strncpy (temp, inote.namedata, inote.namesz);
12776 temp[inote.namesz] = 0;
76da6bbe 12777
6d118b09
NC		 12778 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12779 inote.namedata = temp;
12780 }
12781
12782 res &= process_note (& inote);
103f02d3 12783
6d118b09
NC		 12784 if (temp != NULL)
12785 {
12786 free (temp);
12787 temp = NULL;
12788 }
779fe533
NC		 12789 }
12790
12791 free (pnotes);
103f02d3 12792
779fe533
NC		 12793 return res;
12794}
12795
12796static int
2cf0635d 12797process_corefile_note_segments (FILE * file)
779fe533 12798{
2cf0635d 12799 Elf_Internal_Phdr * segment;
b34976b6
AM		 12800 unsigned int i;
12801 int res = 1;
103f02d3 12802
d93f0186 12803 if (! get_program_headers (file))
779fe533 12804 return 0;
103f02d3 12805
779fe533
NC		 12806 for (i = 0, segment = program_headers;
12807 i < elf_header.e_phnum;
b34976b6 12808 i++, segment++)
779fe533
NC		 12809 {
12810 if (segment->p_type == PT_NOTE)
103f02d3 12811 res &= process_corefile_note_segment (file,
30800947
NC		 12812 (bfd_vma) segment->p_offset,
12813 (bfd_vma) segment->p_filesz);
779fe533 12814 }
103f02d3 12815
779fe533
NC		 12816 return res;
12817}
12818
12819static int
2cf0635d 12820process_note_sections (FILE * file)
1ec5cd37 12821{
2cf0635d 12822 Elf_Internal_Shdr * section;
1ec5cd37
NC		 12823 unsigned long i;
12824 int res = 1;
12825
12826 for (i = 0, section = section_headers;
12827 i < elf_header.e_shnum;
12828 i++, section++)
12829 if (section->sh_type == SHT_NOTE)
12830 res &= process_corefile_note_segment (file,
12831 (bfd_vma) section->sh_offset,
12832 (bfd_vma) section->sh_size);
12833
12834 return res;
12835}
12836
12837static int
2cf0635d 12838process_notes (FILE * file)
779fe533
NC		 12839{
12840 /* If we have not been asked to display the notes then do nothing. */
12841 if (! do_notes)
12842 return 1;
103f02d3 12843
779fe533 12844 if (elf_header.e_type != ET_CORE)
1ec5cd37 12845 return process_note_sections (file);
103f02d3 12846
779fe533 12847 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 12848 if (elf_header.e_phnum > 0)
12849 return process_corefile_note_segments (file);
779fe533 12850
1ec5cd37
NC		 12851 printf (_("No note segments present in the core file.\n"));
12852 return 1;
779fe533
NC		 12853}
12854
252b5132 12855static int
2cf0635d 12856process_arch_specific (FILE * file)
252b5132 12857{
a952a375
NC		 12858 if (! do_arch)
12859 return 1;
12860
252b5132
RH		 12861 switch (elf_header.e_machine)
12862 {
11c1ff18
PB		 12863 case EM_ARM:
12864 return process_arm_specific (file);
252b5132 12865 case EM_MIPS:
4fe85591 12866 case EM_MIPS_RS3_LE:
252b5132
RH		 12867 return process_mips_specific (file);
12868 break;
34c8bcba
JM		 12869 case EM_PPC:
12870 return process_power_specific (file);
12871 break;
59e6276b
JM		 12872 case EM_TI_C6000:
12873 return process_tic6x_specific (file);
12874 break;
252b5132
RH		 12875 default:
12876 break;
12877 }
12878 return 1;
12879}
12880
12881static int
2cf0635d 12882get_file_header (FILE * file)
252b5132 12883{
9ea033b2
NC		 12884 /* Read in the identity array. */
12885 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 12886 return 0;
12887
9ea033b2 12888 /* Determine how to read the rest of the header. */
b34976b6 12889 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 12890 {
12891 default: /* fall through */
12892 case ELFDATANONE: /* fall through */
adab8cdc
AO		 12893 case ELFDATA2LSB:
12894 byte_get = byte_get_little_endian;
12895 byte_put = byte_put_little_endian;
12896 break;
12897 case ELFDATA2MSB:
12898 byte_get = byte_get_big_endian;
12899 byte_put = byte_put_big_endian;
12900 break;
9ea033b2
NC		 12901 }
12902
12903 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 12904 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 12905
12906 /* Read in the rest of the header. */
12907 if (is_32bit_elf)
12908 {
12909 Elf32_External_Ehdr ehdr32;
252b5132 12910
9ea033b2
NC		 12911 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12912 return 0;
103f02d3 12913
9ea033b2
NC		 12914 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12915 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12916 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12917 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12918 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12919 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12920 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12921 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12922 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12923 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12924 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12925 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12926 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12927 }
252b5132 12928 else
9ea033b2
NC		 12929 {
12930 Elf64_External_Ehdr ehdr64;
a952a375
NC		 12931
12932 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12933 we will not be able to cope with the 64bit data found in
12934 64 ELF files. Detect this now and abort before we start
50c2245b 12935 overwriting things. */
a952a375
NC		 12936 if (sizeof (bfd_vma) < 8)
12937 {
e3c8793a
NC		 12938 error (_("This instance of readelf has been built without support for a\n\
1293964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 12940 return 0;
12941 }
103f02d3 12942
9ea033b2
NC		 12943 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12944 return 0;
103f02d3 12945
9ea033b2
NC		 12946 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12947 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12948 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 12949 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12950 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12951 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 12952 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12953 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12954 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12955 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12956 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12957 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12958 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12959 }
252b5132 12960
7ece0d85
JJ		 12961 if (elf_header.e_shoff)
12962 {
12963 /* There may be some extensions in the first section header. Don't
12964 bomb if we can't read it. */
12965 if (is_32bit_elf)
12966 get_32bit_section_headers (file, 1);
12967 else
12968 get_64bit_section_headers (file, 1);
12969 }
560f3c1c 12970
252b5132
RH		 12971 return 1;
12972}
12973
fb52b2f4
NC		 12974/* Process one ELF object file according to the command line options.
12975 This file may actually be stored in an archive. The file is
12976 positioned at the start of the ELF object. */
12977
ff78d6d6 12978static int
2cf0635d 12979process_object (char * file_name, FILE * file)
252b5132 12980{
252b5132
RH		 12981 unsigned int i;
12982
252b5132
RH		 12983 if (! get_file_header (file))
12984 {
12985 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 12986 return 1;
252b5132
RH		 12987 }
12988
12989 /* Initialise per file variables. */
60bca95a 12990 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 12991 version_info[i] = 0;
12992
60bca95a 12993 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 12994 dynamic_info[i] = 0;
5115b233 12995 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 12996
12997 /* Process the file. */
12998 if (show_name)
12999 printf (_("\nFile: %s\n"), file_name);
13000
18bd398b
NC		 13001 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13002 Note we do this even if cmdline_dump_sects is empty because we
13003 must make sure that the dump_sets array is zeroed out before each
13004 object file is processed. */
13005 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13006 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13007
13008 if (num_cmdline_dump_sects > 0)
13009 {
13010 if (num_dump_sects == 0)
13011 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13012 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13013
13014 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13015 memcpy (dump_sects, cmdline_dump_sects,
13016 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13017 }
d70c5fc7 13018
252b5132 13019 if (! process_file_header ())
fb52b2f4 13020 return 1;
252b5132 13021
d1f5c6e3 13022 if (! process_section_headers (file))
2f62977e 13023 {
d1f5c6e3
L		 13024 /* Without loaded section headers we cannot process lots of
13025 things. */
2f62977e 13026 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13027
2f62977e 13028 if (! do_using_dynamic)
2c610e4b 13029 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13030 }
252b5132 13031
d1f5c6e3
L		 13032 if (! process_section_groups (file))
13033 {
13034 /* Without loaded section groups we cannot process unwind. */
13035 do_unwind = 0;
13036 }
13037
2f62977e 13038 if (process_program_headers (file))
b2d38a17 13039 process_dynamic_section (file);
252b5132
RH		 13040
13041 process_relocs (file);
13042
4d6ed7c8
NC		 13043 process_unwind (file);
13044
252b5132
RH		 13045 process_symbol_table (file);
13046
13047 process_syminfo (file);
13048
13049 process_version_sections (file);
13050
13051 process_section_contents (file);
f5842774 13052
1ec5cd37 13053 process_notes (file);
103f02d3 13054
047b2264
JJ		 13055 process_gnu_liblist (file);
13056
252b5132
RH		 13057 process_arch_specific (file);
13058
d93f0186
NC		 13059 if (program_headers)
13060 {
13061 free (program_headers);
13062 program_headers = NULL;
13063 }
13064
252b5132
RH		 13065 if (section_headers)
13066 {
13067 free (section_headers);
13068 section_headers = NULL;
13069 }
13070
13071 if (string_table)
13072 {
13073 free (string_table);
13074 string_table = NULL;
d40ac9bd 13075 string_table_length = 0;
252b5132
RH		 13076 }
13077
13078 if (dynamic_strings)
13079 {
13080 free (dynamic_strings);
13081 dynamic_strings = NULL;
d79b3d50 13082 dynamic_strings_length = 0;
252b5132
RH		 13083 }
13084
13085 if (dynamic_symbols)
13086 {
13087 free (dynamic_symbols);
13088 dynamic_symbols = NULL;
19936277 13089 num_dynamic_syms = 0;
252b5132
RH		 13090 }
13091
13092 if (dynamic_syminfo)
13093 {
13094 free (dynamic_syminfo);
13095 dynamic_syminfo = NULL;
13096 }
ff78d6d6 13097
293c573e
MR		 13098 if (dynamic_section)
13099 {
13100 free (dynamic_section);
13101 dynamic_section = NULL;
13102 }
13103
e4b17d5c
L		 13104 if (section_headers_groups)
13105 {
13106 free (section_headers_groups);
13107 section_headers_groups = NULL;
13108 }
13109
13110 if (section_groups)
13111 {
2cf0635d
NC		 13112 struct group_list * g;
13113 struct group_list * next;
e4b17d5c
L		 13114
13115 for (i = 0; i < group_count; i++)
13116 {
13117 for (g = section_groups [i].root; g != NULL; g = next)
13118 {
13119 next = g->next;
13120 free (g);
13121 }
13122 }
13123
13124 free (section_groups);
13125 section_groups = NULL;
13126 }
13127
19e6b90e 13128 free_debug_memory ();
18bd398b 13129
ff78d6d6 13130 return 0;
252b5132
RH		 13131}
13132
2cf0635d
NC		 13133/* Process an ELF archive.
13134 On entry the file is positioned just after the ARMAG string. */
13135
13136static int
13137process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13138{
13139 struct archive_info arch;
13140 struct archive_info nested_arch;
13141 size_t got;
2cf0635d
NC		 13142 int ret;
13143
13144 show_name = 1;
13145
13146 /* The ARCH structure is used to hold information about this archive. */
13147 arch.file_name = NULL;
13148 arch.file = NULL;
13149 arch.index_array = NULL;
13150 arch.sym_table = NULL;
13151 arch.longnames = NULL;
13152
13153 /* The NESTED_ARCH structure is used as a single-item cache of information
13154 about a nested archive (when members of a thin archive reside within
13155 another regular archive file). */
13156 nested_arch.file_name = NULL;
13157 nested_arch.file = NULL;
13158 nested_arch.index_array = NULL;
13159 nested_arch.sym_table = NULL;
13160 nested_arch.longnames = NULL;
13161
13162 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13163 {
13164 ret = 1;
13165 goto out;
4145f1d5 13166 }
fb52b2f4 13167
4145f1d5
NC		 13168 if (do_archive_index)
13169 {
2cf0635d 13170 if (arch.sym_table == NULL)
4145f1d5
NC		 13171 error (_("%s: unable to dump the index as none was found\n"), file_name);
13172 else
13173 {
2cf0635d 13174 unsigned int i, l;
4145f1d5
NC		 13175 unsigned long current_pos;
13176
13177 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 13178 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 13179 current_pos = ftell (file);
13180
2cf0635d 13181 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13182 {
2cf0635d
NC		 13183 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13184 {
13185 char * member_name;
4145f1d5 13186
2cf0635d
NC		 13187 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13188
13189 if (member_name != NULL)
13190 {
13191 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13192
13193 if (qualified_name != NULL)
13194 {
13195 printf (_("Binary %s contains:\n"), qualified_name);
13196 free (qualified_name);
13197 }
4145f1d5
NC		 13198 }
13199 }
2cf0635d
NC		 13200
13201 if (l >= arch.sym_size)
4145f1d5
NC		 13202 {
13203 error (_("%s: end of the symbol table reached before the end of the index\n"),
13204 file_name);
cb8f3167 13205 break;
4145f1d5 13206 }
2cf0635d
NC		 13207 printf ("\t%s\n", arch.sym_table + l);
13208 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13209 }
13210
2cf0635d
NC		 13211 if (l & 01)
13212 ++l;
13213 if (l < arch.sym_size)
4145f1d5
NC		 13214 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13215 file_name);
13216
4145f1d5
NC		 13217 if (fseek (file, current_pos, SEEK_SET) != 0)
13218 {
13219 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13220 ret = 1;
13221 goto out;
4145f1d5 13222 }
fb52b2f4 13223 }
4145f1d5
NC		 13224
13225 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13226 && !do_segments && !do_header && !do_dump && !do_version
13227 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13228 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13229 {
13230 ret = 0; /* Archive index only. */
13231 goto out;
13232 }
fb52b2f4
NC		 13233 }
13234
d989285c 13235 ret = 0;
fb52b2f4
NC		 13236
13237 while (1)
13238 {
2cf0635d
NC		 13239 char * name;
13240 size_t namelen;
13241 char * qualified_name;
13242
13243 /* Read the next archive header. */
13244 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13245 {
13246 error (_("%s: failed to seek to next archive header\n"), file_name);
13247 return 1;
13248 }
13249 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13250 if (got != sizeof arch.arhdr)
13251 {
13252 if (got == 0)
13253 break;
13254 error (_("%s: failed to read archive header\n"), file_name);
13255 ret = 1;
13256 break;
13257 }
13258 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13259 {
13260 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13261 ret = 1;
13262 break;
13263 }
13264
13265 arch.next_arhdr_offset += sizeof arch.arhdr;
13266
13267 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13268 if (archive_file_size & 01)
13269 ++archive_file_size;
13270
13271 name = get_archive_member_name (&arch, &nested_arch);
13272 if (name == NULL)
fb52b2f4 13273 {
0fd3a477 13274 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13275 ret = 1;
13276 break;
fb52b2f4 13277 }
2cf0635d 13278 namelen = strlen (name);
fb52b2f4 13279
2cf0635d
NC		 13280 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13281 if (qualified_name == NULL)
fb52b2f4 13282 {
2cf0635d 13283 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13284 ret = 1;
13285 break;
fb52b2f4
NC		 13286 }
13287
2cf0635d
NC		 13288 if (is_thin_archive && arch.nested_member_origin == 0)
13289 {
13290 /* This is a proxy for an external member of a thin archive. */
13291 FILE * member_file;
13292 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13293 if (member_file_name == NULL)
13294 {
13295 ret = 1;
13296 break;
13297 }
13298
13299 member_file = fopen (member_file_name, "rb");
13300 if (member_file == NULL)
13301 {
13302 error (_("Input file '%s' is not readable.\n"), member_file_name);
13303 free (member_file_name);
13304 ret = 1;
13305 break;
13306 }
13307
13308 archive_file_offset = arch.nested_member_origin;
13309
13310 ret |= process_object (qualified_name, member_file);
13311
13312 fclose (member_file);
13313 free (member_file_name);
13314 }
13315 else if (is_thin_archive)
13316 {
13317 /* This is a proxy for a member of a nested archive. */
13318 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13319
13320 /* The nested archive file will have been opened and setup by
13321 get_archive_member_name. */
13322 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13323 {
13324 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13325 ret = 1;
13326 break;
13327 }
13328
13329 ret |= process_object (qualified_name, nested_arch.file);
13330 }
13331 else
13332 {
13333 archive_file_offset = arch.next_arhdr_offset;
13334 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13335
2cf0635d
NC		 13336 ret |= process_object (qualified_name, file);
13337 }
fb52b2f4 13338
2b52916e
L		 13339 if (dump_sects != NULL)
13340 {
13341 free (dump_sects);
13342 dump_sects = NULL;
13343 num_dump_sects = 0;
13344 }
13345
2cf0635d 13346 free (qualified_name);
fb52b2f4
NC		 13347 }
13348
4145f1d5 13349 out:
2cf0635d
NC		 13350 if (nested_arch.file != NULL)
13351 fclose (nested_arch.file);
13352 release_archive (&nested_arch);
13353 release_archive (&arch);
fb52b2f4 13354
d989285c 13355 return ret;
fb52b2f4
NC		 13356}
13357
13358static int
2cf0635d 13359process_file (char * file_name)
fb52b2f4 13360{
2cf0635d 13361 FILE * file;
fb52b2f4
NC		 13362 struct stat statbuf;
13363 char armag[SARMAG];
13364 int ret;
13365
13366 if (stat (file_name, &statbuf) < 0)
13367 {
f24ddbdd
NC		 13368 if (errno == ENOENT)
13369 error (_("'%s': No such file\n"), file_name);
13370 else
13371 error (_("Could not locate '%s'. System error message: %s\n"),
13372 file_name, strerror (errno));
13373 return 1;
13374 }
13375
13376 if (! S_ISREG (statbuf.st_mode))
13377 {
13378 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13379 return 1;
13380 }
13381
13382 file = fopen (file_name, "rb");
13383 if (file == NULL)
13384 {
f24ddbdd 13385 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13386 return 1;
13387 }
13388
13389 if (fread (armag, SARMAG, 1, file) != 1)
13390 {
4145f1d5 13391 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13392 fclose (file);
13393 return 1;
13394 }
13395
13396 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13397 ret = process_archive (file_name, file, FALSE);
13398 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13399 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13400 else
13401 {
4145f1d5
NC		 13402 if (do_archive_index)
13403 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13404 file_name);
13405
fb52b2f4
NC		 13406 rewind (file);
13407 archive_file_size = archive_file_offset = 0;
13408 ret = process_object (file_name, file);
13409 }
13410
13411 fclose (file);
13412
13413 return ret;
13414}
13415
252b5132
RH		 13416#ifdef SUPPORT_DISASSEMBLY
13417/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13418 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13419 symbols. */
252b5132
RH		 13420
13421void
2cf0635d 13422print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13423{
13424 fprintf (outfile,"0x%8.8x", addr);
13425}
13426
e3c8793a 13427/* Needed by the i386 disassembler. */
252b5132
RH		 13428void
13429db_task_printsym (unsigned int addr)
13430{
13431 print_address (addr, stderr);
13432}
13433#endif
13434
13435int
2cf0635d 13436main (int argc, char ** argv)
252b5132 13437{
ff78d6d6
L		 13438 int err;
13439
252b5132
RH		 13440#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13441 setlocale (LC_MESSAGES, "");
3882b010
L		 13442#endif
13443#if defined (HAVE_SETLOCALE)
13444 setlocale (LC_CTYPE, "");
252b5132
RH		 13445#endif
13446 bindtextdomain (PACKAGE, LOCALEDIR);
13447 textdomain (PACKAGE);
13448
869b9d07
MM		 13449 expandargv (&argc, &argv);
13450
252b5132
RH		 13451 parse_args (argc, argv);
13452
18bd398b 13453 if (num_dump_sects > 0)
59f14fc0 13454 {
18bd398b 13455 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13456 cmdline_dump_sects = (dump_type *)
13457 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13458 if (cmdline_dump_sects == NULL)
591a748a 13459 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13460 else
13461 {
09c11c86
NC		 13462 memcpy (cmdline_dump_sects, dump_sects,
13463 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13464 num_cmdline_dump_sects = num_dump_sects;
13465 }
13466 }
13467
18bd398b
NC		 13468 if (optind < (argc - 1))
13469 show_name = 1;
13470
ff78d6d6 13471 err = 0;
252b5132 13472 while (optind < argc)
18bd398b 13473 err |= process_file (argv[optind++]);
252b5132
RH		 13474
13475 if (dump_sects != NULL)
13476 free (dump_sects);
59f14fc0
AS		 13477 if (cmdline_dump_sects != NULL)
13478 free (cmdline_dump_sects);
252b5132 13479
ff78d6d6 13480 return err;
252b5132 13481}
GDB Binutils - Deliverables
This page took 2.331864 seconds and 4 git commands to generate.