]> Git Repo - binutils.git/blame - binutils/readelf.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[binutils.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
7a88bc9c 3 2008, 2009, 2010, 2011
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <[email protected]>
12ab83a9 7 Modifications by Nick Clifton <[email protected]>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
1b315056 45#include "config.h"
3db64b00 46#include "sysdep.h"
252b5132
RH		 47#include <assert.h>
48#include <sys/stat.h>
252b5132 49#include <time.h>
1b315056
CS		 50#ifdef HAVE_ZLIB_H
51#include <zlib.h>
52#endif
252b5132 53
a952a375 54#if __GNUC__ >= 2
19936277 55/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 56 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 57 Only do this if we believe that the compiler can support a 64 bit
a952a375 58 data type. For now we only rely on GCC being able to do this. */
19936277 59#define BFD64
a952a375
NC		 60#endif
61
3db64b00
AM		 62#include "bfd.h"
63#include "bucomm.h"
3284fe0c 64#include "elfcomm.h"
19e6b90e 65#include "dwarf.h"
252b5132
RH		 66
67#include "elf/common.h"
68#include "elf/external.h"
69#include "elf/internal.h"
252b5132 70
4b78141a
NC		 71
72/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
76
77#include "elf/h8.h"
78#undef _ELF_H8_H
79
80/* Undo the effects of #including reloc-macros.h. */
81
82#undef START_RELOC_NUMBERS
83#undef RELOC_NUMBER
84#undef FAKE_RELOC
85#undef EMPTY_RELOC
86#undef END_RELOC_NUMBERS
87#undef _RELOC_MACROS_H
88
252b5132
RH		 89/* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
92
93#define RELOC_MACROS_GEN_FUNC
94
252b5132 95#include "elf/alpha.h"
3b16e843 96#include "elf/arc.h"
252b5132 97#include "elf/arm.h"
3b16e843 98#include "elf/avr.h"
1d65ded4 99#include "elf/bfin.h"
60bca95a 100#include "elf/cr16.h"
3b16e843 101#include "elf/cris.h"
1c0d3aa6 102#include "elf/crx.h"
252b5132
RH		 103#include "elf/d10v.h"
104#include "elf/d30v.h"
d172d4ba 105#include "elf/dlx.h"
252b5132 106#include "elf/fr30.h"
5c70f934 107#include "elf/frv.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
7ba29e2a 124#include "elf/microblaze.h"
3b16e843 125#include "elf/mips.h"
3c3bdf30 126#include "elf/mmix.h"
3b16e843
NC		 127#include "elf/mn10200.h"
128#include "elf/mn10300.h"
5506d11a 129#include "elf/moxie.h"
4970f871 130#include "elf/mt.h"
2469cfa2 131#include "elf/msp430.h"
3b16e843 132#include "elf/or32.h"
7d466069 133#include "elf/pj.h"
3b16e843 134#include "elf/ppc.h"
c833c019 135#include "elf/ppc64.h"
c7927a3c 136#include "elf/rx.h"
a85d7ed0 137#include "elf/s390.h"
1c0d3aa6 138#include "elf/score.h"
3b16e843
NC		 139#include "elf/sh.h"
140#include "elf/sparc.h"
e9f53129 141#include "elf/spu.h"
40b36596 142#include "elf/tic6x.h"
aa137e4d
NC		 143#include "elf/tilegx.h"
144#include "elf/tilepro.h"
3b16e843 145#include "elf/v850.h"
179d3252 146#include "elf/vax.h"
3b16e843 147#include "elf/x86-64.h"
c29aca4a 148#include "elf/xc16x.h"
93fbbb04 149#include "elf/xstormy16.h"
88da6820 150#include "elf/xtensa.h"
252b5132 151
252b5132 152#include "getopt.h"
566b0d53 153#include "libiberty.h"
09c11c86 154#include "safe-ctype.h"
2cf0635d 155#include "filenames.h"
252b5132 156
2cf0635d 157char * program_name = "readelf";
85b1c36d
BE		 158static long archive_file_offset;
159static unsigned long archive_file_size;
160static unsigned long dynamic_addr;
161static bfd_size_type dynamic_size;
162static unsigned int dynamic_nent;
2cf0635d 163static char * dynamic_strings;
85b1c36d 164static unsigned long dynamic_strings_length;
2cf0635d 165static char * string_table;
85b1c36d
BE		 166static unsigned long string_table_length;
167static unsigned long num_dynamic_syms;
2cf0635d
NC		 168static Elf_Internal_Sym * dynamic_symbols;
169static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 170static unsigned long dynamic_syminfo_offset;
171static unsigned int dynamic_syminfo_nent;
f8eae8b2 172static char program_interpreter[PATH_MAX];
bb8a0291 173static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 174static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 175static bfd_vma version_info[16];
176static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 177static Elf_Internal_Shdr * section_headers;
178static Elf_Internal_Phdr * program_headers;
179static Elf_Internal_Dyn * dynamic_section;
180static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 181static int show_name;
182static int do_dynamic;
183static int do_syms;
2c610e4b 184static int do_dyn_syms;
85b1c36d
BE		 185static int do_reloc;
186static int do_sections;
187static int do_section_groups;
5477e8a0 188static int do_section_details;
85b1c36d
BE		 189static int do_segments;
190static int do_unwind;
191static int do_using_dynamic;
192static int do_header;
193static int do_dump;
194static int do_version;
85b1c36d
BE		 195static int do_histogram;
196static int do_debugging;
85b1c36d
BE		 197static int do_arch;
198static int do_notes;
4145f1d5 199static int do_archive_index;
85b1c36d 200static int is_32bit_elf;
252b5132 201
e4b17d5c
L		 202struct group_list
203{
2cf0635d 204 struct group_list * next;
e4b17d5c
L		 205 unsigned int section_index;
206};
207
208struct group
209{
2cf0635d 210 struct group_list * root;
e4b17d5c
L		 211 unsigned int group_index;
212};
213
85b1c36d 214static size_t group_count;
2cf0635d
NC		 215static struct group * section_groups;
216static struct group ** section_headers_groups;
e4b17d5c 217
09c11c86
NC		 218
219/* Flag bits indicating particular types of dump. */
220#define HEX_DUMP (1 << 0) /* The -x command line switch. */
221#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
222#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
223#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 224#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 225
226typedef unsigned char dump_type;
227
228/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 229struct dump_list_entry
230{
2cf0635d 231 char * name;
09c11c86 232 dump_type type;
2cf0635d 233 struct dump_list_entry * next;
aef1f6d0 234};
2cf0635d 235static struct dump_list_entry * dump_sects_byname;
aef1f6d0 236
09c11c86
NC		 237/* A dynamic array of flags indicating for which sections a dump
238 has been requested via command line switches. */
239static dump_type * cmdline_dump_sects = NULL;
240static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 241
242/* A dynamic array of flags indicating for which sections a dump of
243 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 244 basis and then initialised from the cmdline_dump_sects array,
245 the results of interpreting the -w switch, and the
246 dump_sects_byname list. */
09c11c86
NC		 247static dump_type * dump_sects = NULL;
248static unsigned int num_dump_sects = 0;
252b5132 249
252b5132 250
c256ffe7 251/* How to print a vma value. */
843dd992
NC		 252typedef enum print_mode
253{
254 HEX,
255 DEC,
256 DEC_5,
257 UNSIGNED,
258 PREFIX_HEX,
259 FULL_HEX,
260 LONG_HEX
261}
262print_mode;
263
9c19a809
NC		 264#define UNKNOWN -1
265
2b692964
NC		 266#define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 270 : string_table + (X)->sh_name))
252b5132 271
ee42cf8c 272#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 273
9ad5cbcf
AM		 274#define GET_ELF_SYMBOLS(file, section) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
276 : get_64bit_elf_symbols (file, section))
9ea033b2 277
d79b3d50
NC		 278#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
279/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
280 already been called and verified that the string exists. */
281#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 282
61865e30
NC		 283#define REMOVE_ARCH_BITS(ADDR) \
284 do \
285 { \
286 if (elf_header.e_machine == EM_ARM) \
287 (ADDR) &= ~1; \
288 } \
289 while (0)
d79b3d50 290\f
59245841
NC		 291/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
292 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
293 using malloc and fill that. In either case return the pointer to the start of
294 the retrieved data or NULL if something went wrong. If something does go wrong
295 emit an error message using REASON as part of the context. */
296
c256ffe7 297static void *
2cf0635d
NC		 298get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
299 const char * reason)
a6e9f9df 300{
2cf0635d 301 void * mvar;
a6e9f9df 302
c256ffe7 303 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 304 return NULL;
305
fb52b2f4 306 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 307 {
0fd3a477 308 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 309 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 310 return NULL;
311 }
312
313 mvar = var;
314 if (mvar == NULL)
315 {
c256ffe7
JJ		 316 /* Check for overflow. */
317 if (nmemb < (~(size_t) 0 - 1) / size)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 320
321 if (mvar == NULL)
322 {
0fd3a477
JW		 323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 325 return NULL;
326 }
c256ffe7
JJ		 327
328 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 329 }
330
c256ffe7 331 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 332 {
0fd3a477
JW		 333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 335 if (mvar != var)
336 free (mvar);
337 return NULL;
338 }
339
340 return mvar;
341}
342
14a91970 343/* Print a VMA value. */
cb8f3167 344
66543521 345static int
14a91970 346print_vma (bfd_vma vma, print_mode mode)
66543521 347{
66543521
AM		 348 int nc = 0;
349
14a91970 350 switch (mode)
66543521 351 {
14a91970
AM		 352 case FULL_HEX:
353 nc = printf ("0x");
354 /* Drop through. */
66543521 355
14a91970 356 case LONG_HEX:
f7a99963 357#ifdef BFD64
14a91970 358 if (is_32bit_elf)
437c2fb7 359 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 360#endif
14a91970
AM		 361 printf_vma (vma);
362 return nc + 16;
b19aac67 363
14a91970
AM		 364 case DEC_5:
365 if (vma <= 99999)
366 return printf ("%5" BFD_VMA_FMT "d", vma);
367 /* Drop through. */
66543521 368
14a91970
AM		 369 case PREFIX_HEX:
370 nc = printf ("0x");
371 /* Drop through. */
66543521 372
14a91970
AM		 373 case HEX:
374 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 375
14a91970
AM		 376 case DEC:
377 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 378
14a91970
AM		 379 case UNSIGNED:
380 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 381 }
66543521 382 return 0;
f7a99963
NC		 383}
384
171191ba 385/* Display a symbol on stdout. Handles the display of non-printing characters.
31104126 386
171191ba
NC		 387 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
388 truncating as necessary. If WIDTH is negative then format the string to be
389 exactly - WIDTH characters, truncating or padding as necessary.
390
391 Returns the number of emitted characters. */
392
393static unsigned int
7a88bc9c 394print_symbol (int width, const char *symbol)
31104126 395{
7a88bc9c 396 const char *c;
171191ba
NC		 397 bfd_boolean extra_padding = FALSE;
398 unsigned int num_printed = 0;
961c521f 399
31104126 400 if (do_wide)
961c521f 401 {
7a88bc9c
AS		 402 /* Set the width to a very large value. This simplifies the
403 code below. */
961c521f
NC		 404 width = INT_MAX;
405 }
31104126 406 else if (width < 0)
961c521f 407 {
961c521f
NC		 408 /* Keep the width positive. This also helps. */
409 width = - width;
171191ba 410 extra_padding = TRUE;
961c521f
NC		 411 }
412
413 while (width)
414 {
415 int len;
416
417 c = symbol;
418
419 /* Look for non-printing symbols inside the symbol's name.
420 This test is triggered in particular by the names generated
421 by the assembler for local labels. */
7a88bc9c 422 while (ISPRINT (*c))
961c521f
NC		 423 c++;
424
425 len = c - symbol;
426
427 if (len)
428 {
429 if (len > width)
430 len = width;
cb8f3167 431
171191ba 432 printf ("%.*s", len, symbol);
961c521f
NC		 433
434 width -= len;
171191ba 435 num_printed += len;
961c521f
NC		 436 }
437
7a88bc9c 438 if (*c == 0 || width == 0)
961c521f
NC		 439 break;
440
441 /* Now display the non-printing character, if
442 there is room left in which to dipslay it. */
7a88bc9c 443 if ((unsigned char) *c < 32)
961c521f
NC		 444 {
445 if (width < 2)
446 break;
447
448 printf ("^%c", *c + 0x40);
449
450 width -= 2;
171191ba 451 num_printed += 2;
961c521f
NC		 452 }
453 else
454 {
455 if (width < 6)
456 break;
cb8f3167 457
7a88bc9c 458 printf ("<0x%.2x>", (unsigned char) *c);
961c521f
NC		 459
460 width -= 6;
171191ba 461 num_printed += 6;
961c521f
NC		 462 }
463
464 symbol = c + 1;
465 }
171191ba
NC		 466
467 if (extra_padding && width > 0)
468 {
469 /* Fill in the remaining spaces. */
470 printf ("%-*s", width, " ");
471 num_printed += 2;
472 }
473
474 return num_printed;
31104126
NC		 475}
476
89fac5e3
RS		 477/* Return a pointer to section NAME, or NULL if no such section exists. */
478
479static Elf_Internal_Shdr *
2cf0635d 480find_section (const char * name)
89fac5e3
RS		 481{
482 unsigned int i;
483
484 for (i = 0; i < elf_header.e_shnum; i++)
485 if (streq (SECTION_NAME (section_headers + i), name))
486 return section_headers + i;
487
488 return NULL;
489}
490
0b6ae522
DJ		 491/* Return a pointer to a section containing ADDR, or NULL if no such
492 section exists. */
493
494static Elf_Internal_Shdr *
495find_section_by_address (bfd_vma addr)
496{
497 unsigned int i;
498
499 for (i = 0; i < elf_header.e_shnum; i++)
500 {
501 Elf_Internal_Shdr *sec = section_headers + i;
502 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
503 return sec;
504 }
505
506 return NULL;
507}
508
509/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
510 bytes read. */
511
512static unsigned long
513read_uleb128 (unsigned char *data, unsigned int *length_return)
514{
515 return read_leb128 (data, length_return, 0);
516}
517
28f997cf
TG		 518/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
519 This OS has so many departures from the ELF standard that we test it at
520 many places. */
521
522static inline int
523is_ia64_vms (void)
524{
525 return elf_header.e_machine == EM_IA_64
526 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
527}
528
bcedfee6 529/* Guess the relocation size commonly used by the specific machines. */
252b5132 530
252b5132 531static int
2dc4cec1 532guess_is_rela (unsigned int e_machine)
252b5132 533{
9c19a809 534 switch (e_machine)
252b5132
RH		 535 {
536 /* Targets that use REL relocations. */
252b5132
RH		 537 case EM_386:
538 case EM_486:
63fcb9e9 539 case EM_960:
e9f53129 540 case EM_ARM:
2b0337b0 541 case EM_D10V:
252b5132 542 case EM_CYGNUS_D10V:
e9f53129 543 case EM_DLX:
252b5132 544 case EM_MIPS:
4fe85591 545 case EM_MIPS_RS3_LE:
e9f53129
AM		 546 case EM_CYGNUS_M32R:
547 case EM_OPENRISC:
548 case EM_OR32:
1c0d3aa6 549 case EM_SCORE:
9c19a809 550 return FALSE;
103f02d3 551
252b5132
RH		 552 /* Targets that use RELA relocations. */
553 case EM_68K:
e9f53129
AM		 554 case EM_860:
555 case EM_ALPHA:
556 case EM_ALTERA_NIOS2:
557 case EM_AVR:
558 case EM_AVR_OLD:
559 case EM_BLACKFIN:
60bca95a 560 case EM_CR16:
6c03b1ed 561 case EM_CR16_OLD:
e9f53129
AM		 562 case EM_CRIS:
563 case EM_CRX:
2b0337b0 564 case EM_D30V:
252b5132 565 case EM_CYGNUS_D30V:
2b0337b0 566 case EM_FR30:
252b5132 567 case EM_CYGNUS_FR30:
5c70f934 568 case EM_CYGNUS_FRV:
e9f53129
AM		 569 case EM_H8S:
570 case EM_H8_300:
571 case EM_H8_300H:
800eeca4 572 case EM_IA_64:
1e4cf259
NC		 573 case EM_IP2K:
574 case EM_IP2K_OLD:
3b36097d 575 case EM_IQ2000:
84e94c90 576 case EM_LATTICEMICO32:
ff7eeb89 577 case EM_M32C_OLD:
49f58d10 578 case EM_M32C:
e9f53129
AM		 579 case EM_M32R:
580 case EM_MCORE:
15ab5209 581 case EM_CYGNUS_MEP:
e9f53129
AM		 582 case EM_MMIX:
583 case EM_MN10200:
584 case EM_CYGNUS_MN10200:
585 case EM_MN10300:
586 case EM_CYGNUS_MN10300:
5506d11a 587 case EM_MOXIE:
e9f53129
AM		 588 case EM_MSP430:
589 case EM_MSP430_OLD:
d031aafb 590 case EM_MT:
64fd6348 591 case EM_NIOS32:
e9f53129
AM		 592 case EM_PPC64:
593 case EM_PPC:
c7927a3c 594 case EM_RX:
e9f53129
AM		 595 case EM_S390:
596 case EM_S390_OLD:
597 case EM_SH:
598 case EM_SPARC:
599 case EM_SPARC32PLUS:
600 case EM_SPARCV9:
601 case EM_SPU:
40b36596 602 case EM_TI_C6000:
aa137e4d
NC		 603 case EM_TILEGX:
604 case EM_TILEPRO:
e9f53129
AM		 605 case EM_V850:
606 case EM_CYGNUS_V850:
607 case EM_VAX:
608 case EM_X86_64:
8a9036a4 609 case EM_L1OM:
7a9068fe 610 case EM_K1OM:
e9f53129
AM		 611 case EM_XSTORMY16:
612 case EM_XTENSA:
613 case EM_XTENSA_OLD:
7ba29e2a
NC		 614 case EM_MICROBLAZE:
615 case EM_MICROBLAZE_OLD:
9c19a809 616 return TRUE;
103f02d3 617
e9f53129
AM		 618 case EM_68HC05:
619 case EM_68HC08:
620 case EM_68HC11:
621 case EM_68HC16:
622 case EM_FX66:
623 case EM_ME16:
d1133906 624 case EM_MMA:
d1133906
NC		 625 case EM_NCPU:
626 case EM_NDR1:
e9f53129 627 case EM_PCP:
d1133906 628 case EM_ST100:
e9f53129 629 case EM_ST19:
d1133906 630 case EM_ST7:
e9f53129
AM		 631 case EM_ST9PLUS:
632 case EM_STARCORE:
d1133906 633 case EM_SVX:
e9f53129 634 case EM_TINYJ:
9c19a809
NC		 635 default:
636 warn (_("Don't know about relocations on this machine architecture\n"));
637 return FALSE;
638 }
639}
252b5132 640
9c19a809 641static int
2cf0635d 642slurp_rela_relocs (FILE * file,
d3ba0551
AM		 643 unsigned long rel_offset,
644 unsigned long rel_size,
2cf0635d
NC		 645 Elf_Internal_Rela ** relasp,
646 unsigned long * nrelasp)
9c19a809 647{
2cf0635d 648 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 649 unsigned long nrelas;
650 unsigned int i;
252b5132 651
4d6ed7c8
NC		 652 if (is_32bit_elf)
653 {
2cf0635d 654 Elf32_External_Rela * erelas;
103f02d3 655
3f5e193b
NC		 656 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
657 rel_size, _("relocs"));
a6e9f9df
AM		 658 if (!erelas)
659 return 0;
252b5132 660
4d6ed7c8 661 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 662
3f5e193b
NC		 663 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
664 sizeof (Elf_Internal_Rela));
103f02d3 665
4d6ed7c8
NC		 666 if (relas == NULL)
667 {
c256ffe7 668 free (erelas);
591a748a 669 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 670 return 0;
671 }
103f02d3 672
4d6ed7c8
NC		 673 for (i = 0; i < nrelas; i++)
674 {
675 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
676 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 677 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 678 }
103f02d3 679
4d6ed7c8
NC		 680 free (erelas);
681 }
682 else
683 {
2cf0635d 684 Elf64_External_Rela * erelas;
103f02d3 685
3f5e193b
NC		 686 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
687 rel_size, _("relocs"));
a6e9f9df
AM		 688 if (!erelas)
689 return 0;
4d6ed7c8
NC		 690
691 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 692
3f5e193b
NC		 693 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
694 sizeof (Elf_Internal_Rela));
103f02d3 695
4d6ed7c8
NC		 696 if (relas == NULL)
697 {
c256ffe7 698 free (erelas);
591a748a 699 error (_("out of memory parsing relocs\n"));
4d6ed7c8 700 return 0;
9c19a809 701 }
4d6ed7c8
NC		 702
703 for (i = 0; i < nrelas; i++)
9c19a809 704 {
66543521
AM		 705 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
706 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 707 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 708
709 /* The #ifdef BFD64 below is to prevent a compile time
710 warning. We know that if we do not have a 64 bit data
711 type that we will never execute this code anyway. */
712#ifdef BFD64
713 if (elf_header.e_machine == EM_MIPS
714 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
715 {
716 /* In little-endian objects, r_info isn't really a
717 64-bit little-endian value: it has a 32-bit
718 little-endian symbol index followed by four
719 individual byte fields. Reorder INFO
720 accordingly. */
91d6fa6a
NC		 721 bfd_vma inf = relas[i].r_info;
722 inf = (((inf & 0xffffffff) << 32)
723 | ((inf >> 56) & 0xff)
724 | ((inf >> 40) & 0xff00)
725 | ((inf >> 24) & 0xff0000)
726 | ((inf >> 8) & 0xff000000));
727 relas[i].r_info = inf;
861fb55a
DJ		 728 }
729#endif /* BFD64 */
4d6ed7c8 730 }
103f02d3 731
4d6ed7c8
NC		 732 free (erelas);
733 }
734 *relasp = relas;
735 *nrelasp = nrelas;
736 return 1;
737}
103f02d3 738
4d6ed7c8 739static int
2cf0635d 740slurp_rel_relocs (FILE * file,
d3ba0551
AM		 741 unsigned long rel_offset,
742 unsigned long rel_size,
2cf0635d
NC		 743 Elf_Internal_Rela ** relsp,
744 unsigned long * nrelsp)
4d6ed7c8 745{
2cf0635d 746 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 747 unsigned long nrels;
748 unsigned int i;
103f02d3 749
4d6ed7c8
NC		 750 if (is_32bit_elf)
751 {
2cf0635d 752 Elf32_External_Rel * erels;
103f02d3 753
3f5e193b
NC		 754 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
755 rel_size, _("relocs"));
a6e9f9df
AM		 756 if (!erels)
757 return 0;
103f02d3 758
4d6ed7c8 759 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 760
3f5e193b 761 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 762
4d6ed7c8
NC		 763 if (rels == NULL)
764 {
c256ffe7 765 free (erels);
591a748a 766 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 767 return 0;
768 }
769
770 for (i = 0; i < nrels; i++)
771 {
772 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
773 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 774 rels[i].r_addend = 0;
9ea033b2 775 }
4d6ed7c8
NC		 776
777 free (erels);
9c19a809
NC		 778 }
779 else
780 {
2cf0635d 781 Elf64_External_Rel * erels;
9ea033b2 782
3f5e193b
NC		 783 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
784 rel_size, _("relocs"));
a6e9f9df
AM		 785 if (!erels)
786 return 0;
103f02d3 787
4d6ed7c8 788 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 789
3f5e193b 790 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 791
4d6ed7c8 792 if (rels == NULL)
9c19a809 793 {
c256ffe7 794 free (erels);
591a748a 795 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 796 return 0;
797 }
103f02d3 798
4d6ed7c8
NC		 799 for (i = 0; i < nrels; i++)
800 {
66543521
AM		 801 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
802 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 803 rels[i].r_addend = 0;
861fb55a
DJ		 804
805 /* The #ifdef BFD64 below is to prevent a compile time
806 warning. We know that if we do not have a 64 bit data
807 type that we will never execute this code anyway. */
808#ifdef BFD64
809 if (elf_header.e_machine == EM_MIPS
810 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
811 {
812 /* In little-endian objects, r_info isn't really a
813 64-bit little-endian value: it has a 32-bit
814 little-endian symbol index followed by four
815 individual byte fields. Reorder INFO
816 accordingly. */
91d6fa6a
NC		 817 bfd_vma inf = rels[i].r_info;
818 inf = (((inf & 0xffffffff) << 32)
819 | ((inf >> 56) & 0xff)
820 | ((inf >> 40) & 0xff00)
821 | ((inf >> 24) & 0xff0000)
822 | ((inf >> 8) & 0xff000000));
823 rels[i].r_info = inf;
861fb55a
DJ		 824 }
825#endif /* BFD64 */
4d6ed7c8 826 }
103f02d3 827
4d6ed7c8
NC		 828 free (erels);
829 }
830 *relsp = rels;
831 *nrelsp = nrels;
832 return 1;
833}
103f02d3 834
aca88567
NC		 835/* Returns the reloc type extracted from the reloc info field. */
836
837static unsigned int
838get_reloc_type (bfd_vma reloc_info)
839{
840 if (is_32bit_elf)
841 return ELF32_R_TYPE (reloc_info);
842
843 switch (elf_header.e_machine)
844 {
845 case EM_MIPS:
846 /* Note: We assume that reloc_info has already been adjusted for us. */
847 return ELF64_MIPS_R_TYPE (reloc_info);
848
849 case EM_SPARCV9:
850 return ELF64_R_TYPE_ID (reloc_info);
851
852 default:
853 return ELF64_R_TYPE (reloc_info);
854 }
855}
856
857/* Return the symbol index extracted from the reloc info field. */
858
859static bfd_vma
860get_reloc_symindex (bfd_vma reloc_info)
861{
862 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
863}
864
d3ba0551
AM		 865/* Display the contents of the relocation data found at the specified
866 offset. */
ee42cf8c 867
41e92641 868static void
2cf0635d 869dump_relocations (FILE * file,
d3ba0551
AM		 870 unsigned long rel_offset,
871 unsigned long rel_size,
2cf0635d 872 Elf_Internal_Sym * symtab,
d3ba0551 873 unsigned long nsyms,
2cf0635d 874 char * strtab,
d79b3d50 875 unsigned long strtablen,
d3ba0551 876 int is_rela)
4d6ed7c8 877{
b34976b6 878 unsigned int i;
2cf0635d 879 Elf_Internal_Rela * rels;
103f02d3 880
4d6ed7c8
NC		 881 if (is_rela == UNKNOWN)
882 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 883
4d6ed7c8
NC		 884 if (is_rela)
885 {
c8286bd1 886 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 887 return;
4d6ed7c8
NC		 888 }
889 else
890 {
891 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 892 return;
252b5132
RH		 893 }
894
410f7a12
L		 895 if (is_32bit_elf)
896 {
897 if (is_rela)
2c71103e
NC		 898 {
899 if (do_wide)
900 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
901 else
902 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
903 }
410f7a12 904 else
2c71103e
NC		 905 {
906 if (do_wide)
907 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
908 else
909 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
910 }
410f7a12 911 }
252b5132 912 else
410f7a12
L		 913 {
914 if (is_rela)
2c71103e
NC		 915 {
916 if (do_wide)
8beeaeb7 917 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 918 else
919 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
920 }
410f7a12 921 else
2c71103e
NC		 922 {
923 if (do_wide)
8beeaeb7 924 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 925 else
926 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
927 }
410f7a12 928 }
252b5132
RH		 929
930 for (i = 0; i < rel_size; i++)
931 {
2cf0635d 932 const char * rtype;
b34976b6 933 bfd_vma offset;
91d6fa6a 934 bfd_vma inf;
b34976b6
AM		 935 bfd_vma symtab_index;
936 bfd_vma type;
103f02d3 937
b34976b6 938 offset = rels[i].r_offset;
91d6fa6a 939 inf = rels[i].r_info;
103f02d3 940
91d6fa6a
NC		 941 type = get_reloc_type (inf);
942 symtab_index = get_reloc_symindex (inf);
252b5132 943
410f7a12
L		 944 if (is_32bit_elf)
945 {
39dbeff8
AM		 946 printf ("%8.8lx %8.8lx ",
947 (unsigned long) offset & 0xffffffff,
91d6fa6a 948 (unsigned long) inf & 0xffffffff);
410f7a12
L		 949 }
950 else
951 {
39dbeff8
AM		 952#if BFD_HOST_64BIT_LONG
953 printf (do_wide
954 ? "%16.16lx %16.16lx "
955 : "%12.12lx %12.12lx ",
91d6fa6a 956 offset, inf);
39dbeff8 957#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 958#ifndef __MSVCRT__
39dbeff8
AM		 959 printf (do_wide
960 ? "%16.16llx %16.16llx "
961 : "%12.12llx %12.12llx ",
91d6fa6a 962 offset, inf);
6e3d6dc1
NC		 963#else
964 printf (do_wide
965 ? "%16.16I64x %16.16I64x "
966 : "%12.12I64x %12.12I64x ",
91d6fa6a 967 offset, inf);
6e3d6dc1 968#endif
39dbeff8 969#else
2c71103e
NC		 970 printf (do_wide
971 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
972 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 973 _bfd_int64_high (offset),
974 _bfd_int64_low (offset),
91d6fa6a
NC		 975 _bfd_int64_high (inf),
976 _bfd_int64_low (inf));
9ea033b2 977#endif
410f7a12 978 }
103f02d3 979
252b5132
RH		 980 switch (elf_header.e_machine)
981 {
982 default:
983 rtype = NULL;
984 break;
985
2b0337b0 986 case EM_M32R:
252b5132 987 case EM_CYGNUS_M32R:
9ea033b2 988 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 989 break;
990
991 case EM_386:
992 case EM_486:
9ea033b2 993 rtype = elf_i386_reloc_type (type);
252b5132
RH		 994 break;
995
ba2685cc
AM		 996 case EM_68HC11:
997 case EM_68HC12:
998 rtype = elf_m68hc11_reloc_type (type);
999 break;
75751cd9 1000
252b5132 1001 case EM_68K:
9ea033b2 1002 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1003 break;
1004
63fcb9e9 1005 case EM_960:
9ea033b2 1006 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1007 break;
1008
adde6300 1009 case EM_AVR:
2b0337b0 1010 case EM_AVR_OLD:
adde6300
AM		 1011 rtype = elf_avr_reloc_type (type);
1012 break;
1013
9ea033b2
NC		 1014 case EM_OLD_SPARCV9:
1015 case EM_SPARC32PLUS:
1016 case EM_SPARCV9:
252b5132 1017 case EM_SPARC:
9ea033b2 1018 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1019 break;
1020
e9f53129
AM		 1021 case EM_SPU:
1022 rtype = elf_spu_reloc_type (type);
1023 break;
1024
2b0337b0 1025 case EM_V850:
252b5132 1026 case EM_CYGNUS_V850:
9ea033b2 1027 rtype = v850_reloc_type (type);
252b5132
RH		 1028 break;
1029
2b0337b0 1030 case EM_D10V:
252b5132 1031 case EM_CYGNUS_D10V:
9ea033b2 1032 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1033 break;
1034
2b0337b0 1035 case EM_D30V:
252b5132 1036 case EM_CYGNUS_D30V:
9ea033b2 1037 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1038 break;
1039
d172d4ba
NC		 1040 case EM_DLX:
1041 rtype = elf_dlx_reloc_type (type);
1042 break;
1043
252b5132 1044 case EM_SH:
9ea033b2 1045 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1046 break;
1047
2b0337b0 1048 case EM_MN10300:
252b5132 1049 case EM_CYGNUS_MN10300:
9ea033b2 1050 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1051 break;
1052
2b0337b0 1053 case EM_MN10200:
252b5132 1054 case EM_CYGNUS_MN10200:
9ea033b2 1055 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1056 break;
1057
2b0337b0 1058 case EM_FR30:
252b5132 1059 case EM_CYGNUS_FR30:
9ea033b2 1060 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1061 break;
1062
ba2685cc
AM		 1063 case EM_CYGNUS_FRV:
1064 rtype = elf_frv_reloc_type (type);
1065 break;
5c70f934 1066
252b5132 1067 case EM_MCORE:
9ea033b2 1068 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1069 break;
1070
3c3bdf30
NC		 1071 case EM_MMIX:
1072 rtype = elf_mmix_reloc_type (type);
1073 break;
1074
5506d11a
AM		 1075 case EM_MOXIE:
1076 rtype = elf_moxie_reloc_type (type);
1077 break;
1078
2469cfa2
NC		 1079 case EM_MSP430:
1080 case EM_MSP430_OLD:
1081 rtype = elf_msp430_reloc_type (type);
1082 break;
1083
252b5132 1084 case EM_PPC:
9ea033b2 1085 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1086 break;
1087
c833c019
AM		 1088 case EM_PPC64:
1089 rtype = elf_ppc64_reloc_type (type);
1090 break;
1091
252b5132 1092 case EM_MIPS:
4fe85591 1093 case EM_MIPS_RS3_LE:
9ea033b2 1094 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1095 break;
1096
1097 case EM_ALPHA:
9ea033b2 1098 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1099 break;
1100
1101 case EM_ARM:
9ea033b2 1102 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1103 break;
1104
584da044 1105 case EM_ARC:
9ea033b2 1106 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1107 break;
1108
1109 case EM_PARISC:
69e617ca 1110 rtype = elf_hppa_reloc_type (type);
252b5132 1111 break;
7d466069 1112
b8720f9d
JL		 1113 case EM_H8_300:
1114 case EM_H8_300H:
1115 case EM_H8S:
1116 rtype = elf_h8_reloc_type (type);
1117 break;
1118
3b16e843
NC		 1119 case EM_OPENRISC:
1120 case EM_OR32:
1121 rtype = elf_or32_reloc_type (type);
1122 break;
1123
7d466069 1124 case EM_PJ:
2b0337b0 1125 case EM_PJ_OLD:
7d466069
ILT		 1126 rtype = elf_pj_reloc_type (type);
1127 break;
800eeca4
JW		 1128 case EM_IA_64:
1129 rtype = elf_ia64_reloc_type (type);
1130 break;
1b61cf92
HPN		 1131
1132 case EM_CRIS:
1133 rtype = elf_cris_reloc_type (type);
1134 break;
535c37ff
JE		 1135
1136 case EM_860:
1137 rtype = elf_i860_reloc_type (type);
1138 break;
bcedfee6
NC		 1139
1140 case EM_X86_64:
8a9036a4 1141 case EM_L1OM:
7a9068fe 1142 case EM_K1OM:
bcedfee6
NC		 1143 rtype = elf_x86_64_reloc_type (type);
1144 break;
a85d7ed0 1145
35b1837e
AM		 1146 case EM_S370:
1147 rtype = i370_reloc_type (type);
1148 break;
1149
53c7db4b
KH		 1150 case EM_S390_OLD:
1151 case EM_S390:
1152 rtype = elf_s390_reloc_type (type);
1153 break;
93fbbb04 1154
1c0d3aa6
NC		 1155 case EM_SCORE:
1156 rtype = elf_score_reloc_type (type);
1157 break;
1158
93fbbb04
GK		 1159 case EM_XSTORMY16:
1160 rtype = elf_xstormy16_reloc_type (type);
1161 break;
179d3252 1162
1fe1f39c
NC		 1163 case EM_CRX:
1164 rtype = elf_crx_reloc_type (type);
1165 break;
1166
179d3252
JT		 1167 case EM_VAX:
1168 rtype = elf_vax_reloc_type (type);
1169 break;
1e4cf259
NC		 1170
1171 case EM_IP2K:
1172 case EM_IP2K_OLD:
1173 rtype = elf_ip2k_reloc_type (type);
1174 break;
3b36097d
SC		 1175
1176 case EM_IQ2000:
1177 rtype = elf_iq2000_reloc_type (type);
1178 break;
88da6820
NC		 1179
1180 case EM_XTENSA_OLD:
1181 case EM_XTENSA:
1182 rtype = elf_xtensa_reloc_type (type);
1183 break;
a34e3ecb 1184
84e94c90
NC		 1185 case EM_LATTICEMICO32:
1186 rtype = elf_lm32_reloc_type (type);
1187 break;
1188
ff7eeb89 1189 case EM_M32C_OLD:
49f58d10
JB		 1190 case EM_M32C:
1191 rtype = elf_m32c_reloc_type (type);
1192 break;
1193
d031aafb
NS		 1194 case EM_MT:
1195 rtype = elf_mt_reloc_type (type);
a34e3ecb 1196 break;
1d65ded4
CM		 1197
1198 case EM_BLACKFIN:
1199 rtype = elf_bfin_reloc_type (type);
1200 break;
15ab5209
DB		 1201
1202 case EM_CYGNUS_MEP:
1203 rtype = elf_mep_reloc_type (type);
1204 break;
60bca95a
NC		 1205
1206 case EM_CR16:
6c03b1ed 1207 case EM_CR16_OLD:
60bca95a
NC		 1208 rtype = elf_cr16_reloc_type (type);
1209 break;
dd24e3da 1210
7ba29e2a
NC		 1211 case EM_MICROBLAZE:
1212 case EM_MICROBLAZE_OLD:
1213 rtype = elf_microblaze_reloc_type (type);
1214 break;
c7927a3c
NC		 1215
1216 case EM_RX:
1217 rtype = elf_rx_reloc_type (type);
1218 break;
c29aca4a
NC		 1219
1220 case EM_XC16X:
1221 case EM_C166:
1222 rtype = elf_xc16x_reloc_type (type);
1223 break;
40b36596
JM		 1224
1225 case EM_TI_C6000:
1226 rtype = elf_tic6x_reloc_type (type);
1227 break;
aa137e4d
NC		 1228
1229 case EM_TILEGX:
1230 rtype = elf_tilegx_reloc_type (type);
1231 break;
1232
1233 case EM_TILEPRO:
1234 rtype = elf_tilepro_reloc_type (type);
1235 break;
252b5132
RH		 1236 }
1237
1238 if (rtype == NULL)
39dbeff8 1239 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1240 else
8beeaeb7 1241 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1242
7ace3541 1243 if (elf_header.e_machine == EM_ALPHA
157c2599 1244 && rtype != NULL
7ace3541
RH		 1245 && streq (rtype, "R_ALPHA_LITUSE")
1246 && is_rela)
1247 {
1248 switch (rels[i].r_addend)
1249 {
1250 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1251 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1252 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1253 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1254 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1255 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1256 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1257 default: rtype = NULL;
1258 }
1259 if (rtype)
1260 printf (" (%s)", rtype);
1261 else
1262 {
1263 putchar (' ');
1264 printf (_("<unknown addend: %lx>"),
1265 (unsigned long) rels[i].r_addend);
1266 }
1267 }
1268 else if (symtab_index)
252b5132 1269 {
af3fc3bc 1270 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1271 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1272 else
19936277 1273 {
2cf0635d 1274 Elf_Internal_Sym * psym;
19936277 1275
af3fc3bc 1276 psym = symtab + symtab_index;
103f02d3 1277
af3fc3bc 1278 printf (" ");
171191ba 1279
d8045f23
NC		 1280 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1281 {
1282 const char * name;
1283 unsigned int len;
1284 unsigned int width = is_32bit_elf ? 8 : 14;
1285
1286 /* Relocations against GNU_IFUNC symbols do not use the value
1287 of the symbol as the address to relocate against. Instead
1288 they invoke the function named by the symbol and use its
1289 result as the address for relocation.
1290
1291 To indicate this to the user, do not display the value of
1292 the symbol in the "Symbols's Value" field. Instead show
1293 its name followed by () as a hint that the symbol is
1294 invoked. */
1295
1296 if (strtab == NULL
1297 || psym->st_name == 0
1298 || psym->st_name >= strtablen)
1299 name = "??";
1300 else
1301 name = strtab + psym->st_name;
1302
1303 len = print_symbol (width, name);
1304 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1305 }
1306 else
1307 {
1308 print_vma (psym->st_value, LONG_HEX);
171191ba 1309
d8045f23
NC		 1310 printf (is_32bit_elf ? " " : " ");
1311 }
103f02d3 1312
af3fc3bc 1313 if (psym->st_name == 0)
f1ef08cb 1314 {
2cf0635d 1315 const char * sec_name = "<null>";
f1ef08cb
AM		 1316 char name_buf[40];
1317
1318 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1319 {
4fbb74a6
AM		 1320 if (psym->st_shndx < elf_header.e_shnum)
1321 sec_name
1322 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1323 else if (psym->st_shndx == SHN_ABS)
1324 sec_name = "ABS";
1325 else if (psym->st_shndx == SHN_COMMON)
1326 sec_name = "COMMON";
ac145307
BS		 1327 else if ((elf_header.e_machine == EM_MIPS
1328 && psym->st_shndx == SHN_MIPS_SCOMMON)
1329 || (elf_header.e_machine == EM_TI_C6000
1330 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1331 sec_name = "SCOMMON";
1332 else if (elf_header.e_machine == EM_MIPS
1333 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1334 sec_name = "SUNDEF";
8a9036a4 1335 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1336 || elf_header.e_machine == EM_L1OM
1337 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1338 && psym->st_shndx == SHN_X86_64_LCOMMON)
1339 sec_name = "LARGE_COMMON";
9ce701e2
L		 1340 else if (elf_header.e_machine == EM_IA_64
1341 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1342 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1343 sec_name = "ANSI_COM";
28f997cf 1344 else if (is_ia64_vms ()
148b93f2
NC		 1345 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1346 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1347 else
1348 {
1349 sprintf (name_buf, "<section 0x%x>",
1350 (unsigned int) psym->st_shndx);
1351 sec_name = name_buf;
1352 }
1353 }
1354 print_symbol (22, sec_name);
1355 }
af3fc3bc 1356 else if (strtab == NULL)
d79b3d50 1357 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1358 else if (psym->st_name >= strtablen)
d79b3d50 1359 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1360 else
2c71103e 1361 print_symbol (22, strtab + psym->st_name);
103f02d3 1362
af3fc3bc 1363 if (is_rela)
171191ba 1364 {
598aaa76 1365 bfd_signed_vma off = rels[i].r_addend;
171191ba 1366
91d6fa6a 1367 if (off < 0)
598aaa76 1368 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1369 else
598aaa76 1370 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1371 }
19936277 1372 }
252b5132 1373 }
1b228002 1374 else if (is_rela)
f7a99963 1375 {
18bd398b
NC		 1376 printf ("%*c", is_32bit_elf ?
1377 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
c8286bd1 1378 print_vma (rels[i].r_addend, LONG_HEX);
f7a99963 1379 }
252b5132 1380
157c2599
NC		 1381 if (elf_header.e_machine == EM_SPARCV9
1382 && rtype != NULL
1383 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1384 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1385
252b5132 1386 putchar ('\n');
2c71103e 1387
aca88567 1388#ifdef BFD64
53c7db4b 1389 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1390 {
91d6fa6a
NC		 1391 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1392 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1393 const char * rtype2 = elf_mips_reloc_type (type2);
1394 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1395
2c71103e
NC		 1396 printf (" Type2: ");
1397
1398 if (rtype2 == NULL)
39dbeff8
AM		 1399 printf (_("unrecognized: %-7lx"),
1400 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1401 else
1402 printf ("%-17.17s", rtype2);
1403
18bd398b 1404 printf ("\n Type3: ");
2c71103e
NC		 1405
1406 if (rtype3 == NULL)
39dbeff8
AM		 1407 printf (_("unrecognized: %-7lx"),
1408 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1409 else
1410 printf ("%-17.17s", rtype3);
1411
53c7db4b 1412 putchar ('\n');
2c71103e 1413 }
aca88567 1414#endif /* BFD64 */
252b5132
RH		 1415 }
1416
c8286bd1 1417 free (rels);
252b5132
RH		 1418}
1419
1420static const char *
d3ba0551 1421get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1422{
1423 switch (type)
1424 {
1425 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1426 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1427 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1428 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1429 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1430 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1431 case DT_MIPS_MSYM: return "MIPS_MSYM";
1432 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1433 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1434 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1435 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1436 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1437 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1438 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1439 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1440 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1441 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1442 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1443 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1444 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1445 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1446 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1447 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1448 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1449 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1450 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1451 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1452 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1453 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1454 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1455 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1456 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1457 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1458 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1459 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1460 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1461 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1462 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1463 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1464 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1465 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1466 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1467 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1468 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1469 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1470 default:
1471 return NULL;
1472 }
1473}
1474
9a097730 1475static const char *
d3ba0551 1476get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1477{
1478 switch (type)
1479 {
1480 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1481 default:
1482 return NULL;
1483 }
103f02d3
UD		 1484}
1485
7490d522
AM		 1486static const char *
1487get_ppc_dynamic_type (unsigned long type)
1488{
1489 switch (type)
1490 {
a7f2871e
AM		 1491 case DT_PPC_GOT: return "PPC_GOT";
1492 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1493 default:
1494 return NULL;
1495 }
1496}
1497
f1cb7e17 1498static const char *
d3ba0551 1499get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1500{
1501 switch (type)
1502 {
a7f2871e
AM		 1503 case DT_PPC64_GLINK: return "PPC64_GLINK";
1504 case DT_PPC64_OPD: return "PPC64_OPD";
1505 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1506 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1507 default:
1508 return NULL;
1509 }
1510}
1511
103f02d3 1512static const char *
d3ba0551 1513get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1514{
1515 switch (type)
1516 {
1517 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1518 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1519 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1520 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1521 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1522 case DT_HP_PREINIT: return "HP_PREINIT";
1523 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1524 case DT_HP_NEEDED: return "HP_NEEDED";
1525 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1526 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1527 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1528 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1529 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1530 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1531 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1532 case DT_HP_FILTERED: return "HP_FILTERED";
1533 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1534 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1535 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1536 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1537 case DT_PLT: return "PLT";
1538 case DT_PLT_SIZE: return "PLT_SIZE";
1539 case DT_DLT: return "DLT";
1540 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1541 default:
1542 return NULL;
1543 }
1544}
9a097730 1545
ecc51f48 1546static const char *
d3ba0551 1547get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1548{
1549 switch (type)
1550 {
148b93f2
NC		 1551 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1552 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1553 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1554 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1555 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1556 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1557 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1558 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1559 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1560 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1561 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1562 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1563 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1564 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1565 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1566 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1567 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1568 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1569 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1570 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1571 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1572 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1573 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1574 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1575 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1576 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1577 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1578 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1579 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1580 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1581 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1582 default:
1583 return NULL;
1584 }
1585}
1586
fabcb361
RH		 1587static const char *
1588get_alpha_dynamic_type (unsigned long type)
1589{
1590 switch (type)
1591 {
1592 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1593 default:
1594 return NULL;
1595 }
1596}
1597
1c0d3aa6
NC		 1598static const char *
1599get_score_dynamic_type (unsigned long type)
1600{
1601 switch (type)
1602 {
1603 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1604 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1605 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1606 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1607 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1608 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1609 default:
1610 return NULL;
1611 }
1612}
1613
40b36596
JM		 1614static const char *
1615get_tic6x_dynamic_type (unsigned long type)
1616{
1617 switch (type)
1618 {
1619 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1620 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1621 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1622 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1623 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1624 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1625 default:
1626 return NULL;
1627 }
1628}
1c0d3aa6 1629
252b5132 1630static const char *
d3ba0551 1631get_dynamic_type (unsigned long type)
252b5132 1632{
e9e44622 1633 static char buff[64];
252b5132
RH		 1634
1635 switch (type)
1636 {
1637 case DT_NULL: return "NULL";
1638 case DT_NEEDED: return "NEEDED";
1639 case DT_PLTRELSZ: return "PLTRELSZ";
1640 case DT_PLTGOT: return "PLTGOT";
1641 case DT_HASH: return "HASH";
1642 case DT_STRTAB: return "STRTAB";
1643 case DT_SYMTAB: return "SYMTAB";
1644 case DT_RELA: return "RELA";
1645 case DT_RELASZ: return "RELASZ";
1646 case DT_RELAENT: return "RELAENT";
1647 case DT_STRSZ: return "STRSZ";
1648 case DT_SYMENT: return "SYMENT";
1649 case DT_INIT: return "INIT";
1650 case DT_FINI: return "FINI";
1651 case DT_SONAME: return "SONAME";
1652 case DT_RPATH: return "RPATH";
1653 case DT_SYMBOLIC: return "SYMBOLIC";
1654 case DT_REL: return "REL";
1655 case DT_RELSZ: return "RELSZ";
1656 case DT_RELENT: return "RELENT";
1657 case DT_PLTREL: return "PLTREL";
1658 case DT_DEBUG: return "DEBUG";
1659 case DT_TEXTREL: return "TEXTREL";
1660 case DT_JMPREL: return "JMPREL";
1661 case DT_BIND_NOW: return "BIND_NOW";
1662 case DT_INIT_ARRAY: return "INIT_ARRAY";
1663 case DT_FINI_ARRAY: return "FINI_ARRAY";
1664 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1665 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1666 case DT_RUNPATH: return "RUNPATH";
1667 case DT_FLAGS: return "FLAGS";
2d0e6f43 1668
d1133906
NC		 1669 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1670 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1671
05107a46 1672 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1673 case DT_PLTPADSZ: return "PLTPADSZ";
1674 case DT_MOVEENT: return "MOVEENT";
1675 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1676 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1677 case DT_POSFLAG_1: return "POSFLAG_1";
1678 case DT_SYMINSZ: return "SYMINSZ";
1679 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1680
252b5132 1681 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1682 case DT_CONFIG: return "CONFIG";
1683 case DT_DEPAUDIT: return "DEPAUDIT";
1684 case DT_AUDIT: return "AUDIT";
1685 case DT_PLTPAD: return "PLTPAD";
1686 case DT_MOVETAB: return "MOVETAB";
252b5132 1687 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1688
252b5132 1689 case DT_VERSYM: return "VERSYM";
103f02d3 1690
67a4f2b7
AO		 1691 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1692 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1693 case DT_RELACOUNT: return "RELACOUNT";
1694 case DT_RELCOUNT: return "RELCOUNT";
1695 case DT_FLAGS_1: return "FLAGS_1";
1696 case DT_VERDEF: return "VERDEF";
1697 case DT_VERDEFNUM: return "VERDEFNUM";
1698 case DT_VERNEED: return "VERNEED";
1699 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1700
019148e4 1701 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1702 case DT_USED: return "USED";
1703 case DT_FILTER: return "FILTER";
103f02d3 1704
047b2264
JJ		 1705 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1706 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1707 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1708 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1709 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1710 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1711
252b5132
RH		 1712 default:
1713 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1714 {
2cf0635d 1715 const char * result;
103f02d3 1716
252b5132
RH		 1717 switch (elf_header.e_machine)
1718 {
1719 case EM_MIPS:
4fe85591 1720 case EM_MIPS_RS3_LE:
252b5132
RH		 1721 result = get_mips_dynamic_type (type);
1722 break;
9a097730
RH		 1723 case EM_SPARCV9:
1724 result = get_sparc64_dynamic_type (type);
1725 break;
7490d522
AM		 1726 case EM_PPC:
1727 result = get_ppc_dynamic_type (type);
1728 break;
f1cb7e17
AM		 1729 case EM_PPC64:
1730 result = get_ppc64_dynamic_type (type);
1731 break;
ecc51f48
NC		 1732 case EM_IA_64:
1733 result = get_ia64_dynamic_type (type);
1734 break;
fabcb361
RH		 1735 case EM_ALPHA:
1736 result = get_alpha_dynamic_type (type);
1737 break;
1c0d3aa6
NC		 1738 case EM_SCORE:
1739 result = get_score_dynamic_type (type);
1740 break;
40b36596
JM		 1741 case EM_TI_C6000:
1742 result = get_tic6x_dynamic_type (type);
1743 break;
252b5132
RH		 1744 default:
1745 result = NULL;
1746 break;
1747 }
1748
1749 if (result != NULL)
1750 return result;
1751
e9e44622 1752 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1753 }
eec8f817
DA		 1754 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1755 || (elf_header.e_machine == EM_PARISC
1756 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1757 {
2cf0635d 1758 const char * result;
103f02d3
UD		 1759
1760 switch (elf_header.e_machine)
1761 {
1762 case EM_PARISC:
1763 result = get_parisc_dynamic_type (type);
1764 break;
148b93f2
NC		 1765 case EM_IA_64:
1766 result = get_ia64_dynamic_type (type);
1767 break;
103f02d3
UD		 1768 default:
1769 result = NULL;
1770 break;
1771 }
1772
1773 if (result != NULL)
1774 return result;
1775
e9e44622
JJ		 1776 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1777 type);
103f02d3 1778 }
252b5132 1779 else
e9e44622 1780 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1781
252b5132
RH		 1782 return buff;
1783 }
1784}
1785
1786static char *
d3ba0551 1787get_file_type (unsigned e_type)
252b5132 1788{
b34976b6 1789 static char buff[32];
252b5132
RH		 1790
1791 switch (e_type)
1792 {
1793 case ET_NONE: return _("NONE (None)");
1794 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1795 case ET_EXEC: return _("EXEC (Executable file)");
1796 case ET_DYN: return _("DYN (Shared object file)");
1797 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1798
1799 default:
1800 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1801 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1802 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1803 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1804 else
e9e44622 1805 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1806 return buff;
1807 }
1808}
1809
1810static char *
d3ba0551 1811get_machine_name (unsigned e_machine)
252b5132 1812{
b34976b6 1813 static char buff[64]; /* XXX */
252b5132
RH		 1814
1815 switch (e_machine)
1816 {
c45021f2
NC		 1817 case EM_NONE: return _("None");
1818 case EM_M32: return "WE32100";
1819 case EM_SPARC: return "Sparc";
e9f53129 1820 case EM_SPU: return "SPU";
c45021f2
NC		 1821 case EM_386: return "Intel 80386";
1822 case EM_68K: return "MC68000";
1823 case EM_88K: return "MC88000";
1824 case EM_486: return "Intel 80486";
1825 case EM_860: return "Intel 80860";
1826 case EM_MIPS: return "MIPS R3000";
1827 case EM_S370: return "IBM System/370";
7036c0e1 1828 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1829 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1830 case EM_PARISC: return "HPPA";
252b5132 1831 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1832 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1833 case EM_960: return "Intel 90860";
1834 case EM_PPC: return "PowerPC";
285d1771 1835 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1836 case EM_V800: return "NEC V800";
1837 case EM_FR20: return "Fujitsu FR20";
1838 case EM_RH32: return "TRW RH32";
b34976b6 1839 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1840 case EM_ARM: return "ARM";
1841 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1842 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1843 case EM_SPARCV9: return "Sparc v9";
1844 case EM_TRICORE: return "Siemens Tricore";
584da044 1845 case EM_ARC: return "ARC";
c2dcd04e
NC		 1846 case EM_H8_300: return "Renesas H8/300";
1847 case EM_H8_300H: return "Renesas H8/300H";
1848 case EM_H8S: return "Renesas H8S";
1849 case EM_H8_500: return "Renesas H8/500";
30800947 1850 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1851 case EM_MIPS_X: return "Stanford MIPS-X";
1852 case EM_COLDFIRE: return "Motorola Coldfire";
1853 case EM_68HC12: return "Motorola M68HC12";
c45021f2 1854 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1855 case EM_CYGNUS_D10V:
1856 case EM_D10V: return "d10v";
1857 case EM_CYGNUS_D30V:
b34976b6 1858 case EM_D30V: return "d30v";
2b0337b0 1859 case EM_CYGNUS_M32R:
26597c86 1860 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1861 case EM_CYGNUS_V850:
8f7e76d0 1862 case EM_V850: return "Renesas v850";
2b0337b0
AO		 1863 case EM_CYGNUS_MN10300:
1864 case EM_MN10300: return "mn10300";
1865 case EM_CYGNUS_MN10200:
1866 case EM_MN10200: return "mn10200";
5506d11a 1867 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1868 case EM_CYGNUS_FR30:
1869 case EM_FR30: return "Fujitsu FR30";
b34976b6 1870 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1871 case EM_PJ_OLD:
b34976b6 1872 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1873 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1874 case EM_PCP: return "Siemens PCP";
1875 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1876 case EM_NDR1: return "Denso NDR1 microprocesspr";
1877 case EM_STARCORE: return "Motorola Star*Core processor";
1878 case EM_ME16: return "Toyota ME16 processor";
1879 case EM_ST100: return "STMicroelectronics ST100 processor";
1880 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1881 case EM_PDSP: return "Sony DSP processor";
1882 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1883 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1884 case EM_FX66: return "Siemens FX66 microcontroller";
1885 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1886 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1887 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1888 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1889 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1890 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1891 case EM_SVX: return "Silicon Graphics SVx";
1892 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1893 case EM_VAX: return "Digital VAX";
2b0337b0 1894 case EM_AVR_OLD:
b34976b6 1895 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1896 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1897 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1898 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1899 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1900 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1901 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1902 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1903 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1904 case EM_L1OM: return "Intel L1OM";
7a9068fe 1905 case EM_K1OM: return "Intel K1OM";
b7498e0e 1906 case EM_S390_OLD:
b34976b6 1907 case EM_S390: return "IBM S/390";
1c0d3aa6 1908 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1909 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1910 case EM_OPENRISC:
1911 case EM_OR32: return "OpenRISC";
11636f9e 1912 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1913 case EM_CRX: return "National Semiconductor CRX microprocessor";
d172d4ba 1914 case EM_DLX: return "OpenDLX";
1e4cf259 1915 case EM_IP2K_OLD:
b34976b6 1916 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1917 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1918 case EM_XTENSA_OLD:
1919 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1920 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1921 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1922 case EM_NS32K: return "National Semiconductor 32000 series";
1923 case EM_TPC: return "Tenor Network TPC processor";
1924 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1925 case EM_MAX: return "MAX Processor";
1926 case EM_CR: return "National Semiconductor CompactRISC";
1927 case EM_F2MC16: return "Fujitsu F2MC16";
1928 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1929 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1930 case EM_M32C_OLD:
49f58d10 1931 case EM_M32C: return "Renesas M32c";
d031aafb 1932 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1933 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1934 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1935 case EM_SEP: return "Sharp embedded microprocessor";
1936 case EM_ARCA: return "Arca RISC microprocessor";
1937 case EM_UNICORE: return "Unicore";
1938 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1939 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1940 case EM_NIOS32: return "Altera Nios";
1941 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1942 case EM_C166:
d70c5fc7 1943 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1944 case EM_M16C: return "Renesas M16C series microprocessors";
1945 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1946 case EM_CE: return "Freescale Communication Engine RISC core";
1947 case EM_TSK3000: return "Altium TSK3000 core";
1948 case EM_RS08: return "Freescale RS08 embedded processor";
1949 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1950 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1951 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1952 case EM_SE_C17: return "Seiko Epson C17 family";
1953 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1954 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1955 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1956 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1957 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1958 case EM_R32C: return "Renesas R32C series microprocessors";
1959 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1960 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1961 case EM_8051: return "Intel 8051 and variants";
1962 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1963 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1964 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1965 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1966 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1967 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1968 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1969 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1970 case EM_CR16:
6c03b1ed 1971 case EM_CR16_OLD: return "National Semiconductor's CR16";
7ba29e2a
NC		 1972 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1973 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
c7927a3c 1974 case EM_RX: return "Renesas RX";
11636f9e
JM		 1975 case EM_METAG: return "Imagination Technologies META processor architecture";
1976 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1977 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1978 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1979 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1980 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1981 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1982 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1983 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 1984 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 1985 case EM_CUDA: return "NVIDIA CUDA architecture";
252b5132 1986 default:
35d9dd2f 1987 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 1988 return buff;
1989 }
1990}
1991
f3485b74 1992static void
d3ba0551 1993decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 1994{
1995 unsigned eabi;
1996 int unknown = 0;
1997
1998 eabi = EF_ARM_EABI_VERSION (e_flags);
1999 e_flags &= ~ EF_ARM_EABIMASK;
2000
2001 /* Handle "generic" ARM flags. */
2002 if (e_flags & EF_ARM_RELEXEC)
2003 {
2004 strcat (buf, ", relocatable executable");
2005 e_flags &= ~ EF_ARM_RELEXEC;
2006 }
76da6bbe 2007
f3485b74
NC		 2008 if (e_flags & EF_ARM_HASENTRY)
2009 {
2010 strcat (buf, ", has entry point");
2011 e_flags &= ~ EF_ARM_HASENTRY;
2012 }
76da6bbe 2013
f3485b74
NC		 2014 /* Now handle EABI specific flags. */
2015 switch (eabi)
2016 {
2017 default:
2c71103e 2018 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2019 if (e_flags)
2020 unknown = 1;
2021 break;
2022
2023 case EF_ARM_EABI_VER1:
a5bcd848 2024 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2025 while (e_flags)
2026 {
2027 unsigned flag;
76da6bbe 2028
f3485b74
NC		 2029 /* Process flags one bit at a time. */
2030 flag = e_flags & - e_flags;
2031 e_flags &= ~ flag;
76da6bbe 2032
f3485b74
NC		 2033 switch (flag)
2034 {
a5bcd848 2035 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2036 strcat (buf, ", sorted symbol tables");
2037 break;
76da6bbe 2038
f3485b74
NC		 2039 default:
2040 unknown = 1;
2041 break;
2042 }
2043 }
2044 break;
76da6bbe 2045
a5bcd848
PB		 2046 case EF_ARM_EABI_VER2:
2047 strcat (buf, ", Version2 EABI");
2048 while (e_flags)
2049 {
2050 unsigned flag;
2051
2052 /* Process flags one bit at a time. */
2053 flag = e_flags & - e_flags;
2054 e_flags &= ~ flag;
2055
2056 switch (flag)
2057 {
2058 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2059 strcat (buf, ", sorted symbol tables");
2060 break;
2061
2062 case EF_ARM_DYNSYMSUSESEGIDX:
2063 strcat (buf, ", dynamic symbols use segment index");
2064 break;
2065
2066 case EF_ARM_MAPSYMSFIRST:
2067 strcat (buf, ", mapping symbols precede others");
2068 break;
2069
2070 default:
2071 unknown = 1;
2072 break;
2073 }
2074 }
2075 break;
2076
d507cf36
PB		 2077 case EF_ARM_EABI_VER3:
2078 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2079 break;
2080
2081 case EF_ARM_EABI_VER4:
2082 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2083 goto eabi;
2084
2085 case EF_ARM_EABI_VER5:
2086 strcat (buf, ", Version5 EABI");
2087 eabi:
d507cf36
PB		 2088 while (e_flags)
2089 {
2090 unsigned flag;
2091
2092 /* Process flags one bit at a time. */
2093 flag = e_flags & - e_flags;
2094 e_flags &= ~ flag;
2095
2096 switch (flag)
2097 {
2098 case EF_ARM_BE8:
2099 strcat (buf, ", BE8");
2100 break;
2101
2102 case EF_ARM_LE8:
2103 strcat (buf, ", LE8");
2104 break;
2105
2106 default:
2107 unknown = 1;
2108 break;
2109 }
2110 }
2111 break;
2112
f3485b74 2113 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2114 strcat (buf, ", GNU EABI");
f3485b74
NC		 2115 while (e_flags)
2116 {
2117 unsigned flag;
76da6bbe 2118
f3485b74
NC		 2119 /* Process flags one bit at a time. */
2120 flag = e_flags & - e_flags;
2121 e_flags &= ~ flag;
76da6bbe 2122
f3485b74
NC		 2123 switch (flag)
2124 {
a5bcd848 2125 case EF_ARM_INTERWORK:
f3485b74
NC		 2126 strcat (buf, ", interworking enabled");
2127 break;
76da6bbe 2128
a5bcd848 2129 case EF_ARM_APCS_26:
f3485b74
NC		 2130 strcat (buf, ", uses APCS/26");
2131 break;
76da6bbe 2132
a5bcd848 2133 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2134 strcat (buf, ", uses APCS/float");
2135 break;
76da6bbe 2136
a5bcd848 2137 case EF_ARM_PIC:
f3485b74
NC		 2138 strcat (buf, ", position independent");
2139 break;
76da6bbe 2140
a5bcd848 2141 case EF_ARM_ALIGN8:
f3485b74
NC		 2142 strcat (buf, ", 8 bit structure alignment");
2143 break;
76da6bbe 2144
a5bcd848 2145 case EF_ARM_NEW_ABI:
f3485b74
NC		 2146 strcat (buf, ", uses new ABI");
2147 break;
76da6bbe 2148
a5bcd848 2149 case EF_ARM_OLD_ABI:
f3485b74
NC		 2150 strcat (buf, ", uses old ABI");
2151 break;
76da6bbe 2152
a5bcd848 2153 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2154 strcat (buf, ", software FP");
2155 break;
76da6bbe 2156
90e01f86
ILT		 2157 case EF_ARM_VFP_FLOAT:
2158 strcat (buf, ", VFP");
2159 break;
2160
fde78edd
NC		 2161 case EF_ARM_MAVERICK_FLOAT:
2162 strcat (buf, ", Maverick FP");
2163 break;
2164
f3485b74
NC		 2165 default:
2166 unknown = 1;
2167 break;
2168 }
2169 }
2170 }
f3485b74
NC		 2171
2172 if (unknown)
2b692964 2173 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2174}
2175
252b5132 2176static char *
d3ba0551 2177get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2178{
b34976b6 2179 static char buf[1024];
252b5132
RH		 2180
2181 buf[0] = '\0';
76da6bbe 2182
252b5132
RH		 2183 if (e_flags)
2184 {
2185 switch (e_machine)
2186 {
2187 default:
2188 break;
2189
f3485b74
NC		 2190 case EM_ARM:
2191 decode_ARM_machine_flags (e_flags, buf);
2192 break;
76da6bbe 2193
781303ce
MF		 2194 case EM_BLACKFIN:
2195 if (e_flags & EF_BFIN_PIC)
2196 strcat (buf, ", PIC");
2197
2198 if (e_flags & EF_BFIN_FDPIC)
2199 strcat (buf, ", FDPIC");
2200
2201 if (e_flags & EF_BFIN_CODE_IN_L1)
2202 strcat (buf, ", code in L1");
2203
2204 if (e_flags & EF_BFIN_DATA_IN_L1)
2205 strcat (buf, ", data in L1");
2206
2207 break;
2208
ec2dfb42
AO		 2209 case EM_CYGNUS_FRV:
2210 switch (e_flags & EF_FRV_CPU_MASK)
2211 {
2212 case EF_FRV_CPU_GENERIC:
2213 break;
2214
2215 default:
2216 strcat (buf, ", fr???");
2217 break;
57346661 2218
ec2dfb42
AO		 2219 case EF_FRV_CPU_FR300:
2220 strcat (buf, ", fr300");
2221 break;
2222
2223 case EF_FRV_CPU_FR400:
2224 strcat (buf, ", fr400");
2225 break;
2226 case EF_FRV_CPU_FR405:
2227 strcat (buf, ", fr405");
2228 break;
2229
2230 case EF_FRV_CPU_FR450:
2231 strcat (buf, ", fr450");
2232 break;
2233
2234 case EF_FRV_CPU_FR500:
2235 strcat (buf, ", fr500");
2236 break;
2237 case EF_FRV_CPU_FR550:
2238 strcat (buf, ", fr550");
2239 break;
2240
2241 case EF_FRV_CPU_SIMPLE:
2242 strcat (buf, ", simple");
2243 break;
2244 case EF_FRV_CPU_TOMCAT:
2245 strcat (buf, ", tomcat");
2246 break;
2247 }
1c877e87 2248 break;
ec2dfb42 2249
53c7db4b 2250 case EM_68K:
425c6cb0 2251 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2252 strcat (buf, ", m68000");
425c6cb0 2253 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2254 strcat (buf, ", cpu32");
2255 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2256 strcat (buf, ", fido_a");
425c6cb0 2257 else
266abb8f 2258 {
2cf0635d
NC		 2259 char const * isa = _("unknown");
2260 char const * mac = _("unknown mac");
2261 char const * additional = NULL;
0112cd26 2262
c694fd50 2263 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2264 {
c694fd50 2265 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2266 isa = "A";
2267 additional = ", nodiv";
2268 break;
c694fd50 2269 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2270 isa = "A";
2271 break;
c694fd50 2272 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2273 isa = "A+";
2274 break;
c694fd50 2275 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2276 isa = "B";
2277 additional = ", nousp";
2278 break;
c694fd50 2279 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2280 isa = "B";
2281 break;
f608cd77
NS		 2282 case EF_M68K_CF_ISA_C:
2283 isa = "C";
2284 break;
2285 case EF_M68K_CF_ISA_C_NODIV:
2286 isa = "C";
2287 additional = ", nodiv";
2288 break;
266abb8f
NS		 2289 }
2290 strcat (buf, ", cf, isa ");
2291 strcat (buf, isa);
0b2e31dc
NS		 2292 if (additional)
2293 strcat (buf, additional);
c694fd50 2294 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2295 strcat (buf, ", float");
c694fd50 2296 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2297 {
2298 case 0:
2299 mac = NULL;
2300 break;
c694fd50 2301 case EF_M68K_CF_MAC:
266abb8f
NS		 2302 mac = "mac";
2303 break;
c694fd50 2304 case EF_M68K_CF_EMAC:
266abb8f
NS		 2305 mac = "emac";
2306 break;
f608cd77
NS		 2307 case EF_M68K_CF_EMAC_B:
2308 mac = "emac_b";
2309 break;
266abb8f
NS		 2310 }
2311 if (mac)
2312 {
2313 strcat (buf, ", ");
2314 strcat (buf, mac);
2315 }
266abb8f 2316 }
53c7db4b 2317 break;
33c63f9d 2318
252b5132
RH		 2319 case EM_PPC:
2320 if (e_flags & EF_PPC_EMB)
2321 strcat (buf, ", emb");
2322
2323 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2324 strcat (buf, _(", relocatable"));
252b5132
RH		 2325
2326 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2327 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2328 break;
2329
2b0337b0 2330 case EM_V850:
252b5132
RH		 2331 case EM_CYGNUS_V850:
2332 switch (e_flags & EF_V850_ARCH)
2333 {
1cd986c5
NC		 2334 case E_V850E2V3_ARCH:
2335 strcat (buf, ", v850e2v3");
2336 break;
2337 case E_V850E2_ARCH:
2338 strcat (buf, ", v850e2");
2339 break;
2340 case E_V850E1_ARCH:
2341 strcat (buf, ", v850e1");
8ad30312 2342 break;
252b5132
RH		 2343 case E_V850E_ARCH:
2344 strcat (buf, ", v850e");
2345 break;
252b5132
RH		 2346 case E_V850_ARCH:
2347 strcat (buf, ", v850");
2348 break;
2349 default:
2b692964 2350 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2351 break;
2352 }
2353 break;
2354
2b0337b0 2355 case EM_M32R:
252b5132
RH		 2356 case EM_CYGNUS_M32R:
2357 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2358 strcat (buf, ", m32r");
252b5132
RH		 2359 break;
2360
2361 case EM_MIPS:
4fe85591 2362 case EM_MIPS_RS3_LE:
252b5132
RH		 2363 if (e_flags & EF_MIPS_NOREORDER)
2364 strcat (buf, ", noreorder");
2365
2366 if (e_flags & EF_MIPS_PIC)
2367 strcat (buf, ", pic");
2368
2369 if (e_flags & EF_MIPS_CPIC)
2370 strcat (buf, ", cpic");
2371
d1bdd336
TS		 2372 if (e_flags & EF_MIPS_UCODE)
2373 strcat (buf, ", ugen_reserved");
2374
252b5132
RH		 2375 if (e_flags & EF_MIPS_ABI2)
2376 strcat (buf, ", abi2");
2377
43521d43
TS		 2378 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2379 strcat (buf, ", odk first");
2380
a5d22d2a
TS		 2381 if (e_flags & EF_MIPS_32BITMODE)
2382 strcat (buf, ", 32bitmode");
2383
156c2f8b
NC		 2384 switch ((e_flags & EF_MIPS_MACH))
2385 {
2386 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2387 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2388 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2389 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2390 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2391 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2392 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2393 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2394 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2395 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2396 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2397 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2398 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2399 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2400 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2401 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2402 case 0:
2403 /* We simply ignore the field in this case to avoid confusion:
2404 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2405 extension. */
2406 break;
2b692964 2407 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2408 }
43521d43
TS		 2409
2410 switch ((e_flags & EF_MIPS_ABI))
2411 {
2412 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2413 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2414 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2415 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2416 case 0:
2417 /* We simply ignore the field in this case to avoid confusion:
2418 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2419 This means it is likely to be an o32 file, but not for
2420 sure. */
2421 break;
2b692964 2422 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2423 }
2424
2425 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2426 strcat (buf, ", mdmx");
2427
2428 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2429 strcat (buf, ", mips16");
2430
df58fc94
RS		 2431 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2432 strcat (buf, ", micromips");
2433
43521d43
TS		 2434 switch ((e_flags & EF_MIPS_ARCH))
2435 {
2436 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2437 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2438 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2439 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2440 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2441 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2442 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2443 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2444 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2445 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2446 }
2447
8e45593f
NC		 2448 if (e_flags & EF_SH_PIC)
2449 strcat (buf, ", pic");
2450
2451 if (e_flags & EF_SH_FDPIC)
2452 strcat (buf, ", fdpic");
252b5132 2453 break;
351b4b40 2454
ccde1100
AO		 2455 case EM_SH:
2456 switch ((e_flags & EF_SH_MACH_MASK))
2457 {
2458 case EF_SH1: strcat (buf, ", sh1"); break;
2459 case EF_SH2: strcat (buf, ", sh2"); break;
2460 case EF_SH3: strcat (buf, ", sh3"); break;
2461 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2462 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2463 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2464 case EF_SH3E: strcat (buf, ", sh3e"); break;
2465 case EF_SH4: strcat (buf, ", sh4"); break;
2466 case EF_SH5: strcat (buf, ", sh5"); break;
2467 case EF_SH2E: strcat (buf, ", sh2e"); break;
2468 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2469 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2470 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2471 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2472 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2473 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2474 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2475 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2476 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2477 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2478 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2479 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2480 }
2481
2482 break;
57346661 2483
351b4b40
RH		 2484 case EM_SPARCV9:
2485 if (e_flags & EF_SPARC_32PLUS)
2486 strcat (buf, ", v8+");
2487
2488 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2489 strcat (buf, ", ultrasparcI");
2490
2491 if (e_flags & EF_SPARC_SUN_US3)
2492 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2493
2494 if (e_flags & EF_SPARC_HAL_R1)
2495 strcat (buf, ", halr1");
2496
2497 if (e_flags & EF_SPARC_LEDATA)
2498 strcat (buf, ", ledata");
2499
2500 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2501 strcat (buf, ", tso");
2502
2503 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2504 strcat (buf, ", pso");
2505
2506 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2507 strcat (buf, ", rmo");
2508 break;
7d466069 2509
103f02d3
UD		 2510 case EM_PARISC:
2511 switch (e_flags & EF_PARISC_ARCH)
2512 {
2513 case EFA_PARISC_1_0:
2514 strcpy (buf, ", PA-RISC 1.0");
2515 break;
2516 case EFA_PARISC_1_1:
2517 strcpy (buf, ", PA-RISC 1.1");
2518 break;
2519 case EFA_PARISC_2_0:
2520 strcpy (buf, ", PA-RISC 2.0");
2521 break;
2522 default:
2523 break;
2524 }
2525 if (e_flags & EF_PARISC_TRAPNIL)
2526 strcat (buf, ", trapnil");
2527 if (e_flags & EF_PARISC_EXT)
2528 strcat (buf, ", ext");
2529 if (e_flags & EF_PARISC_LSB)
2530 strcat (buf, ", lsb");
2531 if (e_flags & EF_PARISC_WIDE)
2532 strcat (buf, ", wide");
2533 if (e_flags & EF_PARISC_NO_KABP)
2534 strcat (buf, ", no kabp");
2535 if (e_flags & EF_PARISC_LAZYSWAP)
2536 strcat (buf, ", lazyswap");
30800947 2537 break;
76da6bbe 2538
7d466069 2539 case EM_PJ:
2b0337b0 2540 case EM_PJ_OLD:
7d466069
ILT		 2541 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2542 strcat (buf, ", new calling convention");
2543
2544 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2545 strcat (buf, ", gnu calling convention");
2546 break;
4d6ed7c8
NC		 2547
2548 case EM_IA_64:
2549 if ((e_flags & EF_IA_64_ABI64))
2550 strcat (buf, ", 64-bit");
2551 else
2552 strcat (buf, ", 32-bit");
2553 if ((e_flags & EF_IA_64_REDUCEDFP))
2554 strcat (buf, ", reduced fp model");
2555 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2556 strcat (buf, ", no function descriptors, constant gp");
2557 else if ((e_flags & EF_IA_64_CONS_GP))
2558 strcat (buf, ", constant gp");
2559 if ((e_flags & EF_IA_64_ABSOLUTE))
2560 strcat (buf, ", absolute");
28f997cf
TG		 2561 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2562 {
2563 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2564 strcat (buf, ", vms_linkages");
2565 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2566 {
2567 case EF_IA_64_VMS_COMCOD_SUCCESS:
2568 break;
2569 case EF_IA_64_VMS_COMCOD_WARNING:
2570 strcat (buf, ", warning");
2571 break;
2572 case EF_IA_64_VMS_COMCOD_ERROR:
2573 strcat (buf, ", error");
2574 break;
2575 case EF_IA_64_VMS_COMCOD_ABORT:
2576 strcat (buf, ", abort");
2577 break;
2578 default:
2579 abort ();
2580 }
2581 }
4d6ed7c8 2582 break;
179d3252
JT		 2583
2584 case EM_VAX:
2585 if ((e_flags & EF_VAX_NONPIC))
2586 strcat (buf, ", non-PIC");
2587 if ((e_flags & EF_VAX_DFLOAT))
2588 strcat (buf, ", D-Float");
2589 if ((e_flags & EF_VAX_GFLOAT))
2590 strcat (buf, ", G-Float");
2591 break;
c7927a3c
NC		 2592
2593 case EM_RX:
2594 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2595 strcat (buf, ", 64-bit doubles");
2596 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2597 strcat (buf, ", dsp");
55786da2
AK		 2598
2599 case EM_S390:
2600 if (e_flags & EF_S390_HIGH_GPRS)
2601 strcat (buf, ", highgprs");
40b36596
JM		 2602
2603 case EM_TI_C6000:
2604 if ((e_flags & EF_C6000_REL))
2605 strcat (buf, ", relocatable module");
252b5132
RH		 2606 }
2607 }
2608
2609 return buf;
2610}
2611
252b5132 2612static const char *
d3ba0551
AM		 2613get_osabi_name (unsigned int osabi)
2614{
2615 static char buff[32];
2616
2617 switch (osabi)
2618 {
2619 case ELFOSABI_NONE: return "UNIX - System V";
2620 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2621 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2622 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2623 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2624 case ELFOSABI_AIX: return "UNIX - AIX";
2625 case ELFOSABI_IRIX: return "UNIX - IRIX";
2626 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2627 case ELFOSABI_TRU64: return "UNIX - TRU64";
2628 case ELFOSABI_MODESTO: return "Novell - Modesto";
2629 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2630 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2631 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2632 case ELFOSABI_AROS: return "AROS";
11636f9e 2633 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2634 default:
40b36596
JM		 2635 if (osabi >= 64)
2636 switch (elf_header.e_machine)
2637 {
2638 case EM_ARM:
2639 switch (osabi)
2640 {
2641 case ELFOSABI_ARM: return "ARM";
2642 default:
2643 break;
2644 }
2645 break;
2646
2647 case EM_MSP430:
2648 case EM_MSP430_OLD:
2649 switch (osabi)
2650 {
2651 case ELFOSABI_STANDALONE: return _("Standalone App");
2652 default:
2653 break;
2654 }
2655 break;
2656
2657 case EM_TI_C6000:
2658 switch (osabi)
2659 {
2660 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2661 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2662 default:
2663 break;
2664 }
2665 break;
2666
2667 default:
2668 break;
2669 }
e9e44622 2670 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2671 return buff;
2672 }
2673}
2674
b294bdf8
MM		 2675static const char *
2676get_arm_segment_type (unsigned long type)
2677{
2678 switch (type)
2679 {
2680 case PT_ARM_EXIDX:
2681 return "EXIDX";
2682 default:
2683 break;
2684 }
2685
2686 return NULL;
2687}
2688
d3ba0551
AM		 2689static const char *
2690get_mips_segment_type (unsigned long type)
252b5132
RH		 2691{
2692 switch (type)
2693 {
2694 case PT_MIPS_REGINFO:
2695 return "REGINFO";
2696 case PT_MIPS_RTPROC:
2697 return "RTPROC";
2698 case PT_MIPS_OPTIONS:
2699 return "OPTIONS";
2700 default:
2701 break;
2702 }
2703
2704 return NULL;
2705}
2706
103f02d3 2707static const char *
d3ba0551 2708get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2709{
2710 switch (type)
2711 {
2712 case PT_HP_TLS: return "HP_TLS";
2713 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2714 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2715 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2716 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2717 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2718 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2719 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2720 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2721 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2722 case PT_HP_PARALLEL: return "HP_PARALLEL";
2723 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2724 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2725 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2726 case PT_HP_STACK: return "HP_STACK";
2727 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2728 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2729 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2730 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2731 default:
2732 break;
2733 }
2734
2735 return NULL;
2736}
2737
4d6ed7c8 2738static const char *
d3ba0551 2739get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2740{
2741 switch (type)
2742 {
2743 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2744 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2745 case PT_HP_TLS: return "HP_TLS";
2746 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2747 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2748 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2749 default:
2750 break;
2751 }
2752
2753 return NULL;
2754}
2755
40b36596
JM		 2756static const char *
2757get_tic6x_segment_type (unsigned long type)
2758{
2759 switch (type)
2760 {
2761 case PT_C6000_PHATTR: return "C6000_PHATTR";
2762 default:
2763 break;
2764 }
2765
2766 return NULL;
2767}
2768
252b5132 2769static const char *
d3ba0551 2770get_segment_type (unsigned long p_type)
252b5132 2771{
b34976b6 2772 static char buff[32];
252b5132
RH		 2773
2774 switch (p_type)
2775 {
b34976b6
AM		 2776 case PT_NULL: return "NULL";
2777 case PT_LOAD: return "LOAD";
252b5132 2778 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2779 case PT_INTERP: return "INTERP";
2780 case PT_NOTE: return "NOTE";
2781 case PT_SHLIB: return "SHLIB";
2782 case PT_PHDR: return "PHDR";
13ae64f3 2783 case PT_TLS: return "TLS";
252b5132 2784
65765700
JJ		 2785 case PT_GNU_EH_FRAME:
2786 return "GNU_EH_FRAME";
2b05f1b7 2787 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2788 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2789
252b5132
RH		 2790 default:
2791 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2792 {
2cf0635d 2793 const char * result;
103f02d3 2794
252b5132
RH		 2795 switch (elf_header.e_machine)
2796 {
b294bdf8
MM		 2797 case EM_ARM:
2798 result = get_arm_segment_type (p_type);
2799 break;
252b5132 2800 case EM_MIPS:
4fe85591 2801 case EM_MIPS_RS3_LE:
252b5132
RH		 2802 result = get_mips_segment_type (p_type);
2803 break;
103f02d3
UD		 2804 case EM_PARISC:
2805 result = get_parisc_segment_type (p_type);
2806 break;
4d6ed7c8
NC		 2807 case EM_IA_64:
2808 result = get_ia64_segment_type (p_type);
2809 break;
40b36596
JM		 2810 case EM_TI_C6000:
2811 result = get_tic6x_segment_type (p_type);
2812 break;
252b5132
RH		 2813 default:
2814 result = NULL;
2815 break;
2816 }
103f02d3 2817
252b5132
RH		 2818 if (result != NULL)
2819 return result;
103f02d3 2820
252b5132
RH		 2821 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2822 }
2823 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2824 {
2cf0635d 2825 const char * result;
103f02d3
UD		 2826
2827 switch (elf_header.e_machine)
2828 {
2829 case EM_PARISC:
2830 result = get_parisc_segment_type (p_type);
2831 break;
00428cca
AM		 2832 case EM_IA_64:
2833 result = get_ia64_segment_type (p_type);
2834 break;
103f02d3
UD		 2835 default:
2836 result = NULL;
2837 break;
2838 }
2839
2840 if (result != NULL)
2841 return result;
2842
2843 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2844 }
252b5132 2845 else
e9e44622 2846 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2847
2848 return buff;
2849 }
2850}
2851
2852static const char *
d3ba0551 2853get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2854{
2855 switch (sh_type)
2856 {
b34976b6
AM		 2857 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2858 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2859 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2860 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2861 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2862 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2863 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2864 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2865 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2866 case SHT_MIPS_RELD: return "MIPS_RELD";
2867 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2868 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2869 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2870 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2871 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2872 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2873 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2874 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2875 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2876 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2877 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2878 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2879 case SHT_MIPS_LINE: return "MIPS_LINE";
2880 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2881 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2882 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2883 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2884 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2885 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2886 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2887 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2888 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2889 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2890 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2891 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2892 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2893 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2894 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2895 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2896 default:
2897 break;
2898 }
2899 return NULL;
2900}
2901
103f02d3 2902static const char *
d3ba0551 2903get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2904{
2905 switch (sh_type)
2906 {
2907 case SHT_PARISC_EXT: return "PARISC_EXT";
2908 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2909 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2910 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2911 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2912 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2913 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2914 default:
2915 break;
2916 }
2917 return NULL;
2918}
2919
4d6ed7c8 2920static const char *
d3ba0551 2921get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2922{
18bd398b 2923 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2924 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2925 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2926
4d6ed7c8
NC		 2927 switch (sh_type)
2928 {
148b93f2
NC		 2929 case SHT_IA_64_EXT: return "IA_64_EXT";
2930 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2931 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2932 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2933 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2934 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2935 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2936 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2937 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2938 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2939 default:
2940 break;
2941 }
2942 return NULL;
2943}
2944
d2b2c203
DJ		 2945static const char *
2946get_x86_64_section_type_name (unsigned int sh_type)
2947{
2948 switch (sh_type)
2949 {
2950 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2951 default:
2952 break;
2953 }
2954 return NULL;
2955}
2956
40a18ebd
NC		 2957static const char *
2958get_arm_section_type_name (unsigned int sh_type)
2959{
2960 switch (sh_type)
2961 {
7f6fed87
NC		 2962 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2963 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2964 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2965 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2966 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 2967 default:
2968 break;
2969 }
2970 return NULL;
2971}
2972
40b36596
JM		 2973static const char *
2974get_tic6x_section_type_name (unsigned int sh_type)
2975{
2976 switch (sh_type)
2977 {
2978 case SHT_C6000_UNWIND:
2979 return "C6000_UNWIND";
2980 case SHT_C6000_PREEMPTMAP:
2981 return "C6000_PREEMPTMAP";
2982 case SHT_C6000_ATTRIBUTES:
2983 return "C6000_ATTRIBUTES";
2984 case SHT_TI_ICODE:
2985 return "TI_ICODE";
2986 case SHT_TI_XREF:
2987 return "TI_XREF";
2988 case SHT_TI_HANDLER:
2989 return "TI_HANDLER";
2990 case SHT_TI_INITINFO:
2991 return "TI_INITINFO";
2992 case SHT_TI_PHATTRS:
2993 return "TI_PHATTRS";
2994 default:
2995 break;
2996 }
2997 return NULL;
2998}
2999
252b5132 3000static const char *
d3ba0551 3001get_section_type_name (unsigned int sh_type)
252b5132 3002{
b34976b6 3003 static char buff[32];
252b5132
RH		 3004
3005 switch (sh_type)
3006 {
3007 case SHT_NULL: return "NULL";
3008 case SHT_PROGBITS: return "PROGBITS";
3009 case SHT_SYMTAB: return "SYMTAB";
3010 case SHT_STRTAB: return "STRTAB";
3011 case SHT_RELA: return "RELA";
3012 case SHT_HASH: return "HASH";
3013 case SHT_DYNAMIC: return "DYNAMIC";
3014 case SHT_NOTE: return "NOTE";
3015 case SHT_NOBITS: return "NOBITS";
3016 case SHT_REL: return "REL";
3017 case SHT_SHLIB: return "SHLIB";
3018 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3019 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3020 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3021 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3022 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3023 case SHT_GROUP: return "GROUP";
3024 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3025 case SHT_GNU_verdef: return "VERDEF";
3026 case SHT_GNU_verneed: return "VERNEED";
3027 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3028 case 0x6ffffff0: return "VERSYM";
3029 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3030 case 0x7ffffffd: return "AUXILIARY";
3031 case 0x7fffffff: return "FILTER";
047b2264 3032 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3033
3034 default:
3035 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3036 {
2cf0635d 3037 const char * result;
252b5132
RH		 3038
3039 switch (elf_header.e_machine)
3040 {
3041 case EM_MIPS:
4fe85591 3042 case EM_MIPS_RS3_LE:
252b5132
RH		 3043 result = get_mips_section_type_name (sh_type);
3044 break;
103f02d3
UD		 3045 case EM_PARISC:
3046 result = get_parisc_section_type_name (sh_type);
3047 break;
4d6ed7c8
NC		 3048 case EM_IA_64:
3049 result = get_ia64_section_type_name (sh_type);
3050 break;
d2b2c203 3051 case EM_X86_64:
8a9036a4 3052 case EM_L1OM:
7a9068fe 3053 case EM_K1OM:
d2b2c203
DJ		 3054 result = get_x86_64_section_type_name (sh_type);
3055 break;
40a18ebd
NC		 3056 case EM_ARM:
3057 result = get_arm_section_type_name (sh_type);
3058 break;
40b36596
JM		 3059 case EM_TI_C6000:
3060 result = get_tic6x_section_type_name (sh_type);
3061 break;
252b5132
RH		 3062 default:
3063 result = NULL;
3064 break;
3065 }
3066
3067 if (result != NULL)
3068 return result;
3069
c91d0dfb 3070 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3071 }
3072 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3073 {
2cf0635d 3074 const char * result;
148b93f2
NC		 3075
3076 switch (elf_header.e_machine)
3077 {
3078 case EM_IA_64:
3079 result = get_ia64_section_type_name (sh_type);
3080 break;
3081 default:
3082 result = NULL;
3083 break;
3084 }
3085
3086 if (result != NULL)
3087 return result;
3088
3089 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3090 }
252b5132 3091 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3092 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3093 else
a7dbfd1c
NC		 3094 /* This message is probably going to be displayed in a 15
3095 character wide field, so put the hex value first. */
3096 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3097
252b5132
RH		 3098 return buff;
3099 }
3100}
3101
2979dc34 3102#define OPTION_DEBUG_DUMP 512
2c610e4b 3103#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3104#define OPTION_DWARF_DEPTH 514
3105#define OPTION_DWARF_START 515
2979dc34 3106
85b1c36d 3107static struct option options[] =
252b5132 3108{
b34976b6 3109 {"all", no_argument, 0, 'a'},
252b5132
RH		 3110 {"file-header", no_argument, 0, 'h'},
3111 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3112 {"headers", no_argument, 0, 'e'},
3113 {"histogram", no_argument, 0, 'I'},
3114 {"segments", no_argument, 0, 'l'},
3115 {"sections", no_argument, 0, 'S'},
252b5132 3116 {"section-headers", no_argument, 0, 'S'},
f5842774 3117 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3118 {"section-details", no_argument, 0, 't'},
595cf52e 3119 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3120 {"symbols", no_argument, 0, 's'},
3121 {"syms", no_argument, 0, 's'},
2c610e4b 3122 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3123 {"relocs", no_argument, 0, 'r'},
3124 {"notes", no_argument, 0, 'n'},
3125 {"dynamic", no_argument, 0, 'd'},
a952a375 3126 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3127 {"version-info", no_argument, 0, 'V'},
3128 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3129 {"unwind", no_argument, 0, 'u'},
4145f1d5 3130 {"archive-index", no_argument, 0, 'c'},
b34976b6 3131 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3132 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3133 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3134#ifdef SUPPORT_DISASSEMBLY
3135 {"instruction-dump", required_argument, 0, 'i'},
3136#endif
cf13d699 3137 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3138
fd2f0033
TT		 3139 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3140 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3141
b34976b6
AM		 3142 {"version", no_argument, 0, 'v'},
3143 {"wide", no_argument, 0, 'W'},
3144 {"help", no_argument, 0, 'H'},
3145 {0, no_argument, 0, 0}
252b5132
RH		 3146};
3147
3148static void
2cf0635d 3149usage (FILE * stream)
252b5132 3150{
92f01d61
JM		 3151 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3152 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3153 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3154 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3155 -h --file-header Display the ELF file header\n\
3156 -l --program-headers Display the program headers\n\
3157 --segments An alias for --program-headers\n\
3158 -S --section-headers Display the sections' header\n\
3159 --sections An alias for --section-headers\n\
f5842774 3160 -g --section-groups Display the section groups\n\
5477e8a0 3161 -t --section-details Display the section details\n\
8b53311e
NC		 3162 -e --headers Equivalent to: -h -l -S\n\
3163 -s --syms Display the symbol table\n\
3f08eb35 3164 --symbols An alias for --syms\n\
2c610e4b 3165 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3166 -n --notes Display the core notes (if present)\n\
3167 -r --relocs Display the relocations (if present)\n\
3168 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3169 -d --dynamic Display the dynamic section (if present)\n\
8b53311e
NC		 3170 -V --version-info Display the version sections (if present)\n\
3171 -A --arch-specific Display architecture specific information (if any).\n\
4145f1d5 3172 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3173 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3174 -x --hex-dump=<number|name>\n\
3175 Dump the contents of section <number|name> as bytes\n\
3176 -p --string-dump=<number|name>\n\
3177 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3178 -R --relocated-dump=<number|name>\n\
3179 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3180 -w[lLiaprmfFsoRt] or\n\
1ed06042 3181 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3182 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3183 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3184 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3185 fprintf (stream, _("\
3186 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3187 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3188 or deeper\n"));
252b5132 3189#ifdef SUPPORT_DISASSEMBLY
92f01d61 3190 fprintf (stream, _("\
09c11c86
NC		 3191 -i --instruction-dump=<number|name>\n\
3192 Disassemble the contents of section <number|name>\n"));
252b5132 3193#endif
92f01d61 3194 fprintf (stream, _("\
8b53311e
NC		 3195 -I --histogram Display histogram of bucket list lengths\n\
3196 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3197 @<file> Read options from <file>\n\
8b53311e
NC		 3198 -H --help Display this information\n\
3199 -v --version Display the version number of readelf\n"));
1118d252 3200
92f01d61
JM		 3201 if (REPORT_BUGS_TO[0] && stream == stdout)
3202 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3203
92f01d61 3204 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3205}
3206
18bd398b
NC		 3207/* Record the fact that the user wants the contents of section number
3208 SECTION to be displayed using the method(s) encoded as flags bits
3209 in TYPE. Note, TYPE can be zero if we are creating the array for
3210 the first time. */
3211
252b5132 3212static void
09c11c86 3213request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3214{
3215 if (section >= num_dump_sects)
3216 {
2cf0635d 3217 dump_type * new_dump_sects;
252b5132 3218
3f5e193b
NC		 3219 new_dump_sects = (dump_type *) calloc (section + 1,
3220 sizeof (* dump_sects));
252b5132
RH		 3221
3222 if (new_dump_sects == NULL)
591a748a 3223 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3224 else
3225 {
3226 /* Copy current flag settings. */
09c11c86 3227 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3228
3229 free (dump_sects);
3230
3231 dump_sects = new_dump_sects;
3232 num_dump_sects = section + 1;
3233 }
3234 }
3235
3236 if (dump_sects)
b34976b6 3237 dump_sects[section] |= type;
252b5132
RH		 3238
3239 return;
3240}
3241
aef1f6d0
DJ		 3242/* Request a dump by section name. */
3243
3244static void
2cf0635d 3245request_dump_byname (const char * section, dump_type type)
aef1f6d0 3246{
2cf0635d 3247 struct dump_list_entry * new_request;
aef1f6d0 3248
3f5e193b
NC		 3249 new_request = (struct dump_list_entry *)
3250 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3251 if (!new_request)
591a748a 3252 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3253
3254 new_request->name = strdup (section);
3255 if (!new_request->name)
591a748a 3256 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3257
3258 new_request->type = type;
3259
3260 new_request->next = dump_sects_byname;
3261 dump_sects_byname = new_request;
3262}
3263
cf13d699
NC		 3264static inline void
3265request_dump (dump_type type)
3266{
3267 int section;
3268 char * cp;
3269
3270 do_dump++;
3271 section = strtoul (optarg, & cp, 0);
3272
3273 if (! *cp && section >= 0)
3274 request_dump_bynumber (section, type);
3275 else
3276 request_dump_byname (optarg, type);
3277}
3278
3279
252b5132 3280static void
2cf0635d 3281parse_args (int argc, char ** argv)
252b5132
RH		 3282{
3283 int c;
3284
3285 if (argc < 2)
92f01d61 3286 usage (stderr);
252b5132
RH		 3287
3288 while ((c = getopt_long
cf13d699 3289 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3290 {
252b5132
RH		 3291 switch (c)
3292 {
3293 case 0:
3294 /* Long options. */
3295 break;
3296 case 'H':
92f01d61 3297 usage (stdout);
252b5132
RH		 3298 break;
3299
3300 case 'a':
b34976b6
AM		 3301 do_syms++;
3302 do_reloc++;
3303 do_unwind++;
3304 do_dynamic++;
3305 do_header++;
3306 do_sections++;
f5842774 3307 do_section_groups++;
b34976b6
AM		 3308 do_segments++;
3309 do_version++;
3310 do_histogram++;
3311 do_arch++;
3312 do_notes++;
252b5132 3313 break;
f5842774
L		 3314 case 'g':
3315 do_section_groups++;
3316 break;
5477e8a0 3317 case 't':
595cf52e 3318 case 'N':
5477e8a0
L		 3319 do_sections++;
3320 do_section_details++;
595cf52e 3321 break;
252b5132 3322 case 'e':
b34976b6
AM		 3323 do_header++;
3324 do_sections++;
3325 do_segments++;
252b5132 3326 break;
a952a375 3327 case 'A':
b34976b6 3328 do_arch++;
a952a375 3329 break;
252b5132 3330 case 'D':
b34976b6 3331 do_using_dynamic++;
252b5132
RH		 3332 break;
3333 case 'r':
b34976b6 3334 do_reloc++;
252b5132 3335 break;
4d6ed7c8 3336 case 'u':
b34976b6 3337 do_unwind++;
4d6ed7c8 3338 break;
252b5132 3339 case 'h':
b34976b6 3340 do_header++;
252b5132
RH		 3341 break;
3342 case 'l':
b34976b6 3343 do_segments++;
252b5132
RH		 3344 break;
3345 case 's':
b34976b6 3346 do_syms++;
252b5132
RH		 3347 break;
3348 case 'S':
b34976b6 3349 do_sections++;
252b5132
RH		 3350 break;
3351 case 'd':
b34976b6 3352 do_dynamic++;
252b5132 3353 break;
a952a375 3354 case 'I':
b34976b6 3355 do_histogram++;
a952a375 3356 break;
779fe533 3357 case 'n':
b34976b6 3358 do_notes++;
779fe533 3359 break;
4145f1d5
NC		 3360 case 'c':
3361 do_archive_index++;
3362 break;
252b5132 3363 case 'x':
cf13d699 3364 request_dump (HEX_DUMP);
aef1f6d0 3365 break;
09c11c86 3366 case 'p':
cf13d699
NC		 3367 request_dump (STRING_DUMP);
3368 break;
3369 case 'R':
3370 request_dump (RELOC_DUMP);
09c11c86 3371 break;
252b5132 3372 case 'w':
b34976b6 3373 do_dump++;
252b5132 3374 if (optarg == 0)
613ff48b
CC		 3375 {
3376 do_debugging = 1;
3377 dwarf_select_sections_all ();
3378 }
252b5132
RH		 3379 else
3380 {
3381 do_debugging = 0;
4cb93e3b 3382 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3383 }
3384 break;
2979dc34 3385 case OPTION_DEBUG_DUMP:
b34976b6 3386 do_dump++;
2979dc34
JJ		 3387 if (optarg == 0)
3388 do_debugging = 1;
3389 else
3390 {
2979dc34 3391 do_debugging = 0;
4cb93e3b 3392 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3393 }
3394 break;
fd2f0033
TT		 3395 case OPTION_DWARF_DEPTH:
3396 {
3397 char *cp;
3398
3399 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3400 }
3401 break;
3402 case OPTION_DWARF_START:
3403 {
3404 char *cp;
3405
3406 dwarf_start_die = strtoul (optarg, & cp, 0);
3407 }
3408 break;
2c610e4b
L		 3409 case OPTION_DYN_SYMS:
3410 do_dyn_syms++;
3411 break;
252b5132
RH		 3412#ifdef SUPPORT_DISASSEMBLY
3413 case 'i':
cf13d699
NC		 3414 request_dump (DISASS_DUMP);
3415 break;
252b5132
RH		 3416#endif
3417 case 'v':
3418 print_version (program_name);
3419 break;
3420 case 'V':
b34976b6 3421 do_version++;
252b5132 3422 break;
d974e256 3423 case 'W':
b34976b6 3424 do_wide++;
d974e256 3425 break;
252b5132 3426 default:
252b5132
RH		 3427 /* xgettext:c-format */
3428 error (_("Invalid option '-%c'\n"), c);
3429 /* Drop through. */
3430 case '?':
92f01d61 3431 usage (stderr);
252b5132
RH		 3432 }
3433 }
3434
4d6ed7c8 3435 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3436 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3437 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3438 && !do_section_groups && !do_archive_index
3439 && !do_dyn_syms)
92f01d61 3440 usage (stderr);
252b5132
RH		 3441 else if (argc < 3)
3442 {
3443 warn (_("Nothing to do.\n"));
92f01d61 3444 usage (stderr);
252b5132
RH		 3445 }
3446}
3447
3448static const char *
d3ba0551 3449get_elf_class (unsigned int elf_class)
252b5132 3450{
b34976b6 3451 static char buff[32];
103f02d3 3452
252b5132
RH		 3453 switch (elf_class)
3454 {
3455 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3456 case ELFCLASS32: return "ELF32";
3457 case ELFCLASS64: return "ELF64";
ab5e7794 3458 default:
e9e44622 3459 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3460 return buff;
252b5132
RH		 3461 }
3462}
3463
3464static const char *
d3ba0551 3465get_data_encoding (unsigned int encoding)
252b5132 3466{
b34976b6 3467 static char buff[32];
103f02d3 3468
252b5132
RH		 3469 switch (encoding)
3470 {
3471 case ELFDATANONE: return _("none");
33c63f9d
CM		 3472 case ELFDATA2LSB: return _("2's complement, little endian");
3473 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3474 default:
e9e44622 3475 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3476 return buff;
252b5132
RH		 3477 }
3478}
3479
252b5132 3480/* Decode the data held in 'elf_header'. */
ee42cf8c 3481
252b5132 3482static int
d3ba0551 3483process_file_header (void)
252b5132 3484{
b34976b6
AM		 3485 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3486 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3487 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3488 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3489 {
3490 error
3491 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3492 return 0;
3493 }
3494
2dc4cec1
L		 3495 init_dwarf_regnames (elf_header.e_machine);
3496
252b5132
RH		 3497 if (do_header)
3498 {
3499 int i;
3500
3501 printf (_("ELF Header:\n"));
3502 printf (_(" Magic: "));
b34976b6
AM		 3503 for (i = 0; i < EI_NIDENT; i++)
3504 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3505 printf ("\n");
3506 printf (_(" Class: %s\n"),
b34976b6 3507 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3508 printf (_(" Data: %s\n"),
b34976b6 3509 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3510 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3511 elf_header.e_ident[EI_VERSION],
3512 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3513 ? "(current)"
b34976b6 3514 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3515 ? _("<unknown: %lx>")
789be9f7 3516 : "")));
252b5132 3517 printf (_(" OS/ABI: %s\n"),
b34976b6 3518 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3519 printf (_(" ABI Version: %d\n"),
b34976b6 3520 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3521 printf (_(" Type: %s\n"),
3522 get_file_type (elf_header.e_type));
3523 printf (_(" Machine: %s\n"),
3524 get_machine_name (elf_header.e_machine));
3525 printf (_(" Version: 0x%lx\n"),
3526 (unsigned long) elf_header.e_version);
76da6bbe 3527
f7a99963
NC		 3528 printf (_(" Entry point address: "));
3529 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3530 printf (_("\n Start of program headers: "));
3531 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3532 printf (_(" (bytes into file)\n Start of section headers: "));
3533 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3534 printf (_(" (bytes into file)\n"));
76da6bbe 3535
252b5132
RH		 3536 printf (_(" Flags: 0x%lx%s\n"),
3537 (unsigned long) elf_header.e_flags,
3538 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3539 printf (_(" Size of this header: %ld (bytes)\n"),
3540 (long) elf_header.e_ehsize);
3541 printf (_(" Size of program headers: %ld (bytes)\n"),
3542 (long) elf_header.e_phentsize);
2046a35d 3543 printf (_(" Number of program headers: %ld"),
252b5132 3544 (long) elf_header.e_phnum);
2046a35d
AM		 3545 if (section_headers != NULL
3546 && elf_header.e_phnum == PN_XNUM
3547 && section_headers[0].sh_info != 0)
cc5914eb 3548 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3549 putc ('\n', stdout);
252b5132
RH		 3550 printf (_(" Size of section headers: %ld (bytes)\n"),
3551 (long) elf_header.e_shentsize);
560f3c1c 3552 printf (_(" Number of section headers: %ld"),
252b5132 3553 (long) elf_header.e_shnum);
4fbb74a6 3554 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3555 printf (" (%ld)", (long) section_headers[0].sh_size);
3556 putc ('\n', stdout);
3557 printf (_(" Section header string table index: %ld"),
252b5132 3558 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3559 if (section_headers != NULL
3560 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3561 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3562 else if (elf_header.e_shstrndx != SHN_UNDEF
3563 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3564 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3565 putc ('\n', stdout);
3566 }
3567
3568 if (section_headers != NULL)
3569 {
2046a35d
AM		 3570 if (elf_header.e_phnum == PN_XNUM
3571 && section_headers[0].sh_info != 0)
3572 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3573 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3574 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3575 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3576 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3577 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3578 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3579 free (section_headers);
3580 section_headers = NULL;
252b5132 3581 }
103f02d3 3582
9ea033b2
NC		 3583 return 1;
3584}
3585
252b5132 3586
9ea033b2 3587static int
91d6fa6a 3588get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3589{
2cf0635d
NC		 3590 Elf32_External_Phdr * phdrs;
3591 Elf32_External_Phdr * external;
3592 Elf_Internal_Phdr * internal;
b34976b6 3593 unsigned int i;
103f02d3 3594
3f5e193b
NC		 3595 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3596 elf_header.e_phentsize,
3597 elf_header.e_phnum,
3598 _("program headers"));
a6e9f9df
AM		 3599 if (!phdrs)
3600 return 0;
9ea033b2 3601
91d6fa6a 3602 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3603 i < elf_header.e_phnum;
b34976b6 3604 i++, internal++, external++)
252b5132 3605 {
9ea033b2
NC		 3606 internal->p_type = BYTE_GET (external->p_type);
3607 internal->p_offset = BYTE_GET (external->p_offset);
3608 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3609 internal->p_paddr = BYTE_GET (external->p_paddr);
3610 internal->p_filesz = BYTE_GET (external->p_filesz);
3611 internal->p_memsz = BYTE_GET (external->p_memsz);
3612 internal->p_flags = BYTE_GET (external->p_flags);
3613 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3614 }
3615
9ea033b2
NC		 3616 free (phdrs);
3617
252b5132
RH		 3618 return 1;
3619}
3620
9ea033b2 3621static int
91d6fa6a 3622get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3623{
2cf0635d
NC		 3624 Elf64_External_Phdr * phdrs;
3625 Elf64_External_Phdr * external;
3626 Elf_Internal_Phdr * internal;
b34976b6 3627 unsigned int i;
103f02d3 3628
3f5e193b
NC		 3629 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3630 elf_header.e_phentsize,
3631 elf_header.e_phnum,
3632 _("program headers"));
a6e9f9df
AM		 3633 if (!phdrs)
3634 return 0;
9ea033b2 3635
91d6fa6a 3636 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3637 i < elf_header.e_phnum;
b34976b6 3638 i++, internal++, external++)
9ea033b2
NC		 3639 {
3640 internal->p_type = BYTE_GET (external->p_type);
3641 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3642 internal->p_offset = BYTE_GET (external->p_offset);
3643 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3644 internal->p_paddr = BYTE_GET (external->p_paddr);
3645 internal->p_filesz = BYTE_GET (external->p_filesz);
3646 internal->p_memsz = BYTE_GET (external->p_memsz);
3647 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3648 }
3649
3650 free (phdrs);
3651
3652 return 1;
3653}
252b5132 3654
d93f0186
NC		 3655/* Returns 1 if the program headers were read into `program_headers'. */
3656
3657static int
2cf0635d 3658get_program_headers (FILE * file)
d93f0186 3659{
2cf0635d 3660 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3661
3662 /* Check cache of prior read. */
3663 if (program_headers != NULL)
3664 return 1;
3665
3f5e193b
NC		 3666 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3667 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3668
3669 if (phdrs == NULL)
3670 {
3671 error (_("Out of memory\n"));
3672 return 0;
3673 }
3674
3675 if (is_32bit_elf
3676 ? get_32bit_program_headers (file, phdrs)
3677 : get_64bit_program_headers (file, phdrs))
3678 {
3679 program_headers = phdrs;
3680 return 1;
3681 }
3682
3683 free (phdrs);
3684 return 0;
3685}
3686
2f62977e
NC		 3687/* Returns 1 if the program headers were loaded. */
3688
252b5132 3689static int
2cf0635d 3690process_program_headers (FILE * file)
252b5132 3691{
2cf0635d 3692 Elf_Internal_Phdr * segment;
b34976b6 3693 unsigned int i;
252b5132
RH		 3694
3695 if (elf_header.e_phnum == 0)
3696 {
82f2dbf7
NC		 3697 /* PR binutils/12467. */
3698 if (elf_header.e_phoff != 0)
3699 warn (_("possibly corrupt ELF header - it has a non-zero program"
3700 " header offset, but no program headers"));
3701 else if (do_segments)
252b5132 3702 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3703 return 0;
252b5132
RH		 3704 }
3705
3706 if (do_segments && !do_header)
3707 {
f7a99963
NC		 3708 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3709 printf (_("Entry point "));
3710 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3711 printf (_("\nThere are %d program headers, starting at offset "),
3712 elf_header.e_phnum);
3713 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3714 printf ("\n");
252b5132
RH		 3715 }
3716
d93f0186 3717 if (! get_program_headers (file))
252b5132 3718 return 0;
103f02d3 3719
252b5132
RH		 3720 if (do_segments)
3721 {
3a1a2036
NC		 3722 if (elf_header.e_phnum > 1)
3723 printf (_("\nProgram Headers:\n"));
3724 else
3725 printf (_("\nProgram Headers:\n"));
76da6bbe 3726
f7a99963
NC		 3727 if (is_32bit_elf)
3728 printf
3729 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3730 else if (do_wide)
3731 printf
3732 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3733 else
3734 {
3735 printf
3736 (_(" Type Offset VirtAddr PhysAddr\n"));
3737 printf
3738 (_(" FileSiz MemSiz Flags Align\n"));
3739 }
252b5132
RH		 3740 }
3741
252b5132 3742 dynamic_addr = 0;
1b228002 3743 dynamic_size = 0;
252b5132
RH		 3744
3745 for (i = 0, segment = program_headers;
3746 i < elf_header.e_phnum;
b34976b6 3747 i++, segment++)
252b5132
RH		 3748 {
3749 if (do_segments)
3750 {
103f02d3 3751 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3752
3753 if (is_32bit_elf)
3754 {
3755 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3756 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3757 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3758 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3759 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3760 printf ("%c%c%c ",
3761 (segment->p_flags & PF_R ? 'R' : ' '),
3762 (segment->p_flags & PF_W ? 'W' : ' '),
3763 (segment->p_flags & PF_X ? 'E' : ' '));
3764 printf ("%#lx", (unsigned long) segment->p_align);
3765 }
d974e256
JJ		 3766 else if (do_wide)
3767 {
3768 if ((unsigned long) segment->p_offset == segment->p_offset)
3769 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3770 else
3771 {
3772 print_vma (segment->p_offset, FULL_HEX);
3773 putchar (' ');
3774 }
3775
3776 print_vma (segment->p_vaddr, FULL_HEX);
3777 putchar (' ');
3778 print_vma (segment->p_paddr, FULL_HEX);
3779 putchar (' ');
3780
3781 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3782 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3783 else
3784 {
3785 print_vma (segment->p_filesz, FULL_HEX);
3786 putchar (' ');
3787 }
3788
3789 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3790 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3791 else
3792 {
3793 print_vma (segment->p_offset, FULL_HEX);
3794 }
3795
3796 printf (" %c%c%c ",
3797 (segment->p_flags & PF_R ? 'R' : ' '),
3798 (segment->p_flags & PF_W ? 'W' : ' '),
3799 (segment->p_flags & PF_X ? 'E' : ' '));
3800
3801 if ((unsigned long) segment->p_align == segment->p_align)
3802 printf ("%#lx", (unsigned long) segment->p_align);
3803 else
3804 {
3805 print_vma (segment->p_align, PREFIX_HEX);
3806 }
3807 }
f7a99963
NC		 3808 else
3809 {
3810 print_vma (segment->p_offset, FULL_HEX);
3811 putchar (' ');
3812 print_vma (segment->p_vaddr, FULL_HEX);
3813 putchar (' ');
3814 print_vma (segment->p_paddr, FULL_HEX);
3815 printf ("\n ");
3816 print_vma (segment->p_filesz, FULL_HEX);
3817 putchar (' ');
3818 print_vma (segment->p_memsz, FULL_HEX);
3819 printf (" %c%c%c ",
3820 (segment->p_flags & PF_R ? 'R' : ' '),
3821 (segment->p_flags & PF_W ? 'W' : ' '),
3822 (segment->p_flags & PF_X ? 'E' : ' '));
3823 print_vma (segment->p_align, HEX);
3824 }
252b5132
RH		 3825 }
3826
3827 switch (segment->p_type)
3828 {
252b5132
RH		 3829 case PT_DYNAMIC:
3830 if (dynamic_addr)
3831 error (_("more than one dynamic segment\n"));
3832
20737c13
AM		 3833 /* By default, assume that the .dynamic section is the first
3834 section in the DYNAMIC segment. */
3835 dynamic_addr = segment->p_offset;
3836 dynamic_size = segment->p_filesz;
3837
b2d38a17
NC		 3838 /* Try to locate the .dynamic section. If there is
3839 a section header table, we can easily locate it. */
3840 if (section_headers != NULL)
3841 {
2cf0635d 3842 Elf_Internal_Shdr * sec;
b2d38a17 3843
89fac5e3
RS		 3844 sec = find_section (".dynamic");
3845 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3846 {
28f997cf
TG		 3847 /* A corresponding .dynamic section is expected, but on
3848 IA-64/OpenVMS it is OK for it to be missing. */
3849 if (!is_ia64_vms ())
3850 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3851 break;
3852 }
3853
42bb2e33 3854 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3855 {
3856 dynamic_size = 0;
3857 break;
3858 }
42bb2e33 3859
b2d38a17
NC		 3860 dynamic_addr = sec->sh_offset;
3861 dynamic_size = sec->sh_size;
3862
3863 if (dynamic_addr < segment->p_offset
3864 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3865 warn (_("the .dynamic section is not contained"
3866 " within the dynamic segment\n"));
b2d38a17 3867 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3868 warn (_("the .dynamic section is not the first section"
3869 " in the dynamic segment.\n"));
b2d38a17 3870 }
252b5132
RH		 3871 break;
3872
3873 case PT_INTERP:
fb52b2f4
NC		 3874 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3875 SEEK_SET))
252b5132
RH		 3876 error (_("Unable to find program interpreter name\n"));
3877 else
3878 {
f8eae8b2
L		 3879 char fmt [32];
3880 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3881
3882 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3883 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3884
252b5132 3885 program_interpreter[0] = 0;
7bd7b3ef
AM		 3886 if (fscanf (file, fmt, program_interpreter) <= 0)
3887 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3888
3889 if (do_segments)
3890 printf (_("\n [Requesting program interpreter: %s]"),
3891 program_interpreter);
3892 }
3893 break;
3894 }
3895
3896 if (do_segments)
3897 putc ('\n', stdout);
3898 }
3899
c256ffe7 3900 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3901 {
3902 printf (_("\n Section to Segment mapping:\n"));
3903 printf (_(" Segment Sections...\n"));
3904
252b5132
RH		 3905 for (i = 0; i < elf_header.e_phnum; i++)
3906 {
9ad5cbcf 3907 unsigned int j;
2cf0635d 3908 Elf_Internal_Shdr * section;
252b5132
RH		 3909
3910 segment = program_headers + i;
b391a3e3 3911 section = section_headers + 1;
252b5132
RH		 3912
3913 printf (" %2.2d ", i);
3914
b34976b6 3915 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3916 {
f4638467
AM		 3917 if (!ELF_TBSS_SPECIAL (section, segment)
3918 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3919 printf ("%s ", SECTION_NAME (section));
3920 }
3921
3922 putc ('\n',stdout);
3923 }
3924 }
3925
252b5132
RH		 3926 return 1;
3927}
3928
3929
d93f0186
NC		 3930/* Find the file offset corresponding to VMA by using the program headers. */
3931
3932static long
2cf0635d 3933offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 3934{
2cf0635d 3935 Elf_Internal_Phdr * seg;
d93f0186
NC		 3936
3937 if (! get_program_headers (file))
3938 {
3939 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3940 return (long) vma;
3941 }
3942
3943 for (seg = program_headers;
3944 seg < program_headers + elf_header.e_phnum;
3945 ++seg)
3946 {
3947 if (seg->p_type != PT_LOAD)
3948 continue;
3949
3950 if (vma >= (seg->p_vaddr & -seg->p_align)
3951 && vma + size <= seg->p_vaddr + seg->p_filesz)
3952 return vma - seg->p_vaddr + seg->p_offset;
3953 }
3954
3955 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 3956 (unsigned long) vma);
d93f0186
NC		 3957 return (long) vma;
3958}
3959
3960
252b5132 3961static int
2cf0635d 3962get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 3963{
2cf0635d
NC		 3964 Elf32_External_Shdr * shdrs;
3965 Elf_Internal_Shdr * internal;
b34976b6 3966 unsigned int i;
252b5132 3967
3f5e193b
NC		 3968 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3969 elf_header.e_shentsize, num,
3970 _("section headers"));
a6e9f9df
AM		 3971 if (!shdrs)
3972 return 0;
252b5132 3973
3f5e193b
NC		 3974 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3975 sizeof (Elf_Internal_Shdr));
252b5132
RH		 3976
3977 if (section_headers == NULL)
3978 {
3979 error (_("Out of memory\n"));
3980 return 0;
3981 }
3982
3983 for (i = 0, internal = section_headers;
560f3c1c 3984 i < num;
b34976b6 3985 i++, internal++)
252b5132
RH		 3986 {
3987 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3988 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3989 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3990 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3991 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3992 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3993 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3994 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3995 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3996 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3997 }
3998
3999 free (shdrs);
4000
4001 return 1;
4002}
4003
9ea033b2 4004static int
2cf0635d 4005get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4006{
2cf0635d
NC		 4007 Elf64_External_Shdr * shdrs;
4008 Elf_Internal_Shdr * internal;
b34976b6 4009 unsigned int i;
9ea033b2 4010
3f5e193b
NC		 4011 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4012 elf_header.e_shentsize, num,
4013 _("section headers"));
a6e9f9df
AM		 4014 if (!shdrs)
4015 return 0;
9ea033b2 4016
3f5e193b
NC		 4017 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4018 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4019
4020 if (section_headers == NULL)
4021 {
4022 error (_("Out of memory\n"));
4023 return 0;
4024 }
4025
4026 for (i = 0, internal = section_headers;
560f3c1c 4027 i < num;
b34976b6 4028 i++, internal++)
9ea033b2
NC		 4029 {
4030 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4031 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4032 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4033 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4034 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4035 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4036 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4037 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4038 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4039 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4040 }
4041
4042 free (shdrs);
4043
4044 return 1;
4045}
4046
252b5132 4047static Elf_Internal_Sym *
2cf0635d 4048get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
252b5132 4049{
9ad5cbcf 4050 unsigned long number;
dd24e3da 4051 Elf32_External_Sym * esyms = NULL;
2cf0635d 4052 Elf_External_Sym_Shndx * shndx;
dd24e3da 4053 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4054 Elf_Internal_Sym * psym;
b34976b6 4055 unsigned int j;
252b5132 4056
dd24e3da
NC		 4057 /* Run some sanity checks first. */
4058 if (section->sh_entsize == 0)
4059 {
4060 error (_("sh_entsize is zero\n"));
4061 return NULL;
4062 }
4063
4064 number = section->sh_size / section->sh_entsize;
4065
4066 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4067 {
4068 error (_("Invalid sh_entsize\n"));
4069 return NULL;
4070 }
4071
3f5e193b
NC		 4072 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4073 section->sh_size, _("symbols"));
dd24e3da 4074 if (esyms == NULL)
a6e9f9df 4075 return NULL;
252b5132 4076
9ad5cbcf
AM		 4077 shndx = NULL;
4078 if (symtab_shndx_hdr != NULL
4079 && (symtab_shndx_hdr->sh_link
4fbb74a6 4080 == (unsigned long) (section - section_headers)))
9ad5cbcf 4081 {
3f5e193b
NC		 4082 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4083 symtab_shndx_hdr->sh_offset,
4084 1, symtab_shndx_hdr->sh_size,
4085 _("symtab shndx"));
dd24e3da
NC		 4086 if (shndx == NULL)
4087 goto exit_point;
9ad5cbcf
AM		 4088 }
4089
3f5e193b 4090 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4091
4092 if (isyms == NULL)
4093 {
4094 error (_("Out of memory\n"));
dd24e3da 4095 goto exit_point;
252b5132
RH		 4096 }
4097
dd24e3da 4098 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4099 {
4100 psym->st_name = BYTE_GET (esyms[j].st_name);
4101 psym->st_value = BYTE_GET (esyms[j].st_value);
4102 psym->st_size = BYTE_GET (esyms[j].st_size);
4103 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4104 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4105 psym->st_shndx
4106 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4107 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4108 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4109 psym->st_info = BYTE_GET (esyms[j].st_info);
4110 psym->st_other = BYTE_GET (esyms[j].st_other);
4111 }
4112
dd24e3da 4113 exit_point:
9ad5cbcf
AM		 4114 if (shndx)
4115 free (shndx);
dd24e3da
NC		 4116 if (esyms)
4117 free (esyms);
252b5132
RH		 4118
4119 return isyms;
4120}
4121
9ea033b2 4122static Elf_Internal_Sym *
2cf0635d 4123get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
9ea033b2 4124{
9ad5cbcf 4125 unsigned long number;
2cf0635d
NC		 4126 Elf64_External_Sym * esyms;
4127 Elf_External_Sym_Shndx * shndx;
4128 Elf_Internal_Sym * isyms;
4129 Elf_Internal_Sym * psym;
b34976b6 4130 unsigned int j;
9ea033b2 4131
dd24e3da
NC		 4132 /* Run some sanity checks first. */
4133 if (section->sh_entsize == 0)
4134 {
4135 error (_("sh_entsize is zero\n"));
4136 return NULL;
4137 }
4138
4139 number = section->sh_size / section->sh_entsize;
4140
4141 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4142 {
4143 error (_("Invalid sh_entsize\n"));
4144 return NULL;
4145 }
4146
3f5e193b
NC		 4147 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4148 section->sh_size, _("symbols"));
a6e9f9df
AM		 4149 if (!esyms)
4150 return NULL;
9ea033b2 4151
9ad5cbcf
AM		 4152 shndx = NULL;
4153 if (symtab_shndx_hdr != NULL
4154 && (symtab_shndx_hdr->sh_link
4fbb74a6 4155 == (unsigned long) (section - section_headers)))
9ad5cbcf 4156 {
3f5e193b
NC		 4157 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4158 symtab_shndx_hdr->sh_offset,
4159 1, symtab_shndx_hdr->sh_size,
4160 _("symtab shndx"));
9ad5cbcf
AM		 4161 if (!shndx)
4162 {
4163 free (esyms);
4164 return NULL;
4165 }
4166 }
4167
3f5e193b 4168 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4169
4170 if (isyms == NULL)
4171 {
4172 error (_("Out of memory\n"));
9ad5cbcf
AM		 4173 if (shndx)
4174 free (shndx);
9ea033b2 4175 free (esyms);
9ea033b2
NC		 4176 return NULL;
4177 }
4178
4179 for (j = 0, psym = isyms;
4180 j < number;
b34976b6 4181 j++, psym++)
9ea033b2
NC		 4182 {
4183 psym->st_name = BYTE_GET (esyms[j].st_name);
4184 psym->st_info = BYTE_GET (esyms[j].st_info);
4185 psym->st_other = BYTE_GET (esyms[j].st_other);
4186 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4187 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4188 psym->st_shndx
4189 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4190 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4191 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
66543521
AM		 4192 psym->st_value = BYTE_GET (esyms[j].st_value);
4193 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4194 }
4195
9ad5cbcf
AM		 4196 if (shndx)
4197 free (shndx);
9ea033b2
NC		 4198 free (esyms);
4199
4200 return isyms;
4201}
4202
d1133906 4203static const char *
d3ba0551 4204get_elf_section_flags (bfd_vma sh_flags)
d1133906 4205{
5477e8a0 4206 static char buff[1024];
2cf0635d 4207 char * p = buff;
8d5ff12c 4208 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4209 int sindex;
4210 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4211 bfd_vma os_flags = 0;
4212 bfd_vma proc_flags = 0;
4213 bfd_vma unknown_flags = 0;
148b93f2 4214 static const struct
5477e8a0 4215 {
2cf0635d 4216 const char * str;
5477e8a0
L		 4217 int len;
4218 }
4219 flags [] =
4220 {
cfcac11d
NC		 4221 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4222 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4223 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4224 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4225 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4226 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4227 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4228 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4229 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4230 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4231 /* IA-64 specific. */
4232 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4233 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4234 /* IA-64 OpenVMS specific. */
4235 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4236 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4237 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4238 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4239 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4240 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4241 /* Generic. */
cfcac11d 4242 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4243 /* SPARC specific. */
cfcac11d 4244 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4245 };
4246
4247 if (do_section_details)
4248 {
8d5ff12c
L		 4249 sprintf (buff, "[%*.*lx]: ",
4250 field_size, field_size, (unsigned long) sh_flags);
4251 p += field_size + 4;
5477e8a0 4252 }
76da6bbe 4253
d1133906
NC		 4254 while (sh_flags)
4255 {
4256 bfd_vma flag;
4257
4258 flag = sh_flags & - sh_flags;
4259 sh_flags &= ~ flag;
76da6bbe 4260
5477e8a0 4261 if (do_section_details)
d1133906 4262 {
5477e8a0
L		 4263 switch (flag)
4264 {
91d6fa6a
NC		 4265 case SHF_WRITE: sindex = 0; break;
4266 case SHF_ALLOC: sindex = 1; break;
4267 case SHF_EXECINSTR: sindex = 2; break;
4268 case SHF_MERGE: sindex = 3; break;
4269 case SHF_STRINGS: sindex = 4; break;
4270 case SHF_INFO_LINK: sindex = 5; break;
4271 case SHF_LINK_ORDER: sindex = 6; break;
4272 case SHF_OS_NONCONFORMING: sindex = 7; break;
4273 case SHF_GROUP: sindex = 8; break;
4274 case SHF_TLS: sindex = 9; break;
18ae9cc1 4275 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4276
5477e8a0 4277 default:
91d6fa6a 4278 sindex = -1;
cfcac11d 4279 switch (elf_header.e_machine)
148b93f2 4280 {
cfcac11d 4281 case EM_IA_64:
148b93f2 4282 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4283 sindex = 10;
148b93f2 4284 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4285 sindex = 11;
148b93f2
NC		 4286#ifdef BFD64
4287 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4288 switch (flag)
4289 {
91d6fa6a
NC		 4290 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4291 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4292 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4293 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4294 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4295 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4296 default: break;
4297 }
4298#endif
cfcac11d
NC		 4299 break;
4300
caa83f8b
NC		 4301 case EM_386:
4302 case EM_486:
4303 case EM_X86_64:
7f502d6c 4304 case EM_L1OM:
7a9068fe 4305 case EM_K1OM:
cfcac11d
NC		 4306 case EM_OLD_SPARCV9:
4307 case EM_SPARC32PLUS:
4308 case EM_SPARCV9:
4309 case EM_SPARC:
18ae9cc1 4310 if (flag == SHF_ORDERED)
91d6fa6a 4311 sindex = 19;
cfcac11d
NC		 4312 break;
4313 default:
4314 break;
148b93f2 4315 }
5477e8a0
L		 4316 }
4317
91d6fa6a 4318 if (sindex != -1)
5477e8a0 4319 {
8d5ff12c
L		 4320 if (p != buff + field_size + 4)
4321 {
4322 if (size < (10 + 2))
4323 abort ();
4324 size -= 2;
4325 *p++ = ',';
4326 *p++ = ' ';
4327 }
4328
91d6fa6a
NC		 4329 size -= flags [sindex].len;
4330 p = stpcpy (p, flags [sindex].str);
5477e8a0 4331 }
3b22753a 4332 else if (flag & SHF_MASKOS)
8d5ff12c 4333 os_flags |= flag;
d1133906 4334 else if (flag & SHF_MASKPROC)
8d5ff12c 4335 proc_flags |= flag;
d1133906 4336 else
8d5ff12c 4337 unknown_flags |= flag;
5477e8a0
L		 4338 }
4339 else
4340 {
4341 switch (flag)
4342 {
4343 case SHF_WRITE: *p = 'W'; break;
4344 case SHF_ALLOC: *p = 'A'; break;
4345 case SHF_EXECINSTR: *p = 'X'; break;
4346 case SHF_MERGE: *p = 'M'; break;
4347 case SHF_STRINGS: *p = 'S'; break;
4348 case SHF_INFO_LINK: *p = 'I'; break;
4349 case SHF_LINK_ORDER: *p = 'L'; break;
4350 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4351 case SHF_GROUP: *p = 'G'; break;
4352 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4353 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4354
4355 default:
8a9036a4 4356 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4357 || elf_header.e_machine == EM_L1OM
4358 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4359 && flag == SHF_X86_64_LARGE)
4360 *p = 'l';
4361 else if (flag & SHF_MASKOS)
4362 {
4363 *p = 'o';
4364 sh_flags &= ~ SHF_MASKOS;
4365 }
4366 else if (flag & SHF_MASKPROC)
4367 {
4368 *p = 'p';
4369 sh_flags &= ~ SHF_MASKPROC;
4370 }
4371 else
4372 *p = 'x';
4373 break;
4374 }
4375 p++;
d1133906
NC		 4376 }
4377 }
76da6bbe 4378
8d5ff12c
L		 4379 if (do_section_details)
4380 {
4381 if (os_flags)
4382 {
4383 size -= 5 + field_size;
4384 if (p != buff + field_size + 4)
4385 {
4386 if (size < (2 + 1))
4387 abort ();
4388 size -= 2;
4389 *p++ = ',';
4390 *p++ = ' ';
4391 }
4392 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4393 (unsigned long) os_flags);
4394 p += 5 + field_size;
4395 }
4396 if (proc_flags)
4397 {
4398 size -= 7 + field_size;
4399 if (p != buff + field_size + 4)
4400 {
4401 if (size < (2 + 1))
4402 abort ();
4403 size -= 2;
4404 *p++ = ',';
4405 *p++ = ' ';
4406 }
4407 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4408 (unsigned long) proc_flags);
4409 p += 7 + field_size;
4410 }
4411 if (unknown_flags)
4412 {
4413 size -= 10 + field_size;
4414 if (p != buff + field_size + 4)
4415 {
4416 if (size < (2 + 1))
4417 abort ();
4418 size -= 2;
4419 *p++ = ',';
4420 *p++ = ' ';
4421 }
2b692964 4422 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4423 (unsigned long) unknown_flags);
4424 p += 10 + field_size;
4425 }
4426 }
4427
e9e44622 4428 *p = '\0';
d1133906
NC		 4429 return buff;
4430}
4431
252b5132 4432static int
2cf0635d 4433process_section_headers (FILE * file)
252b5132 4434{
2cf0635d 4435 Elf_Internal_Shdr * section;
b34976b6 4436 unsigned int i;
252b5132
RH		 4437
4438 section_headers = NULL;
4439
4440 if (elf_header.e_shnum == 0)
4441 {
82f2dbf7
NC		 4442 /* PR binutils/12467. */
4443 if (elf_header.e_shoff != 0)
4444 warn (_("possibly corrupt ELF file header - it has a non-zero"
4445 " section header offset, but no section headers\n"));
4446 else if (do_sections)
252b5132
RH		 4447 printf (_("\nThere are no sections in this file.\n"));
4448
4449 return 1;
4450 }
4451
4452 if (do_sections && !do_header)
9ea033b2 4453 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4454 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4455
9ea033b2
NC		 4456 if (is_32bit_elf)
4457 {
560f3c1c 4458 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4459 return 0;
4460 }
560f3c1c 4461 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4462 return 0;
4463
4464 /* Read in the string table, so that we have names to display. */
0b49d371 4465 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4466 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4467 {
4fbb74a6 4468 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4469
c256ffe7
JJ		 4470 if (section->sh_size != 0)
4471 {
3f5e193b
NC		 4472 string_table = (char *) get_data (NULL, file, section->sh_offset,
4473 1, section->sh_size,
4474 _("string table"));
0de14b54 4475
c256ffe7
JJ		 4476 string_table_length = string_table != NULL ? section->sh_size : 0;
4477 }
252b5132
RH		 4478 }
4479
4480 /* Scan the sections for the dynamic symbol table
e3c8793a 4481 and dynamic string table and debug sections. */
252b5132
RH		 4482 dynamic_symbols = NULL;
4483 dynamic_strings = NULL;
4484 dynamic_syminfo = NULL;
f1ef08cb 4485 symtab_shndx_hdr = NULL;
103f02d3 4486
89fac5e3
RS		 4487 eh_addr_size = is_32bit_elf ? 4 : 8;
4488 switch (elf_header.e_machine)
4489 {
4490 case EM_MIPS:
4491 case EM_MIPS_RS3_LE:
4492 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4493 FDE addresses. However, the ABI also has a semi-official ILP32
4494 variant for which the normal FDE address size rules apply.
4495
4496 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4497 section, where XX is the size of longs in bits. Unfortunately,
4498 earlier compilers provided no way of distinguishing ILP32 objects
4499 from LP64 objects, so if there's any doubt, we should assume that
4500 the official LP64 form is being used. */
4501 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4502 && find_section (".gcc_compiled_long32") == NULL)
4503 eh_addr_size = 8;
4504 break;
0f56a26a
DD		 4505
4506 case EM_H8_300:
4507 case EM_H8_300H:
4508 switch (elf_header.e_flags & EF_H8_MACH)
4509 {
4510 case E_H8_MACH_H8300:
4511 case E_H8_MACH_H8300HN:
4512 case E_H8_MACH_H8300SN:
4513 case E_H8_MACH_H8300SXN:
4514 eh_addr_size = 2;
4515 break;
4516 case E_H8_MACH_H8300H:
4517 case E_H8_MACH_H8300S:
4518 case E_H8_MACH_H8300SX:
4519 eh_addr_size = 4;
4520 break;
4521 }
f4236fe4
DD		 4522 break;
4523
ff7eeb89 4524 case EM_M32C_OLD:
f4236fe4
DD		 4525 case EM_M32C:
4526 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4527 {
4528 case EF_M32C_CPU_M16C:
4529 eh_addr_size = 2;
4530 break;
4531 }
4532 break;
89fac5e3
RS		 4533 }
4534
08d8fa11
JJ		 4535#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4536 do \
4537 { \
4538 size_t expected_entsize \
4539 = is_32bit_elf ? size32 : size64; \
4540 if (section->sh_entsize != expected_entsize) \
4541 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4542 i, (unsigned long int) section->sh_entsize, \
4543 (unsigned long int) expected_entsize); \
4544 section->sh_entsize = expected_entsize; \
4545 } \
4546 while (0)
4547#define CHECK_ENTSIZE(section, i, type) \
4548 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4549 sizeof (Elf64_External_##type))
4550
252b5132
RH		 4551 for (i = 0, section = section_headers;
4552 i < elf_header.e_shnum;
b34976b6 4553 i++, section++)
252b5132 4554 {
2cf0635d 4555 char * name = SECTION_NAME (section);
252b5132
RH		 4556
4557 if (section->sh_type == SHT_DYNSYM)
4558 {
4559 if (dynamic_symbols != NULL)
4560 {
4561 error (_("File contains multiple dynamic symbol tables\n"));
4562 continue;
4563 }
4564
08d8fa11 4565 CHECK_ENTSIZE (section, i, Sym);
19936277 4566 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ad5cbcf 4567 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 4568 }
4569 else if (section->sh_type == SHT_STRTAB
18bd398b 4570 && streq (name, ".dynstr"))
252b5132
RH		 4571 {
4572 if (dynamic_strings != NULL)
4573 {
4574 error (_("File contains multiple dynamic string tables\n"));
4575 continue;
4576 }
4577
3f5e193b
NC		 4578 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4579 1, section->sh_size,
4580 _("dynamic strings"));
59245841 4581 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4582 }
9ad5cbcf
AM		 4583 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4584 {
4585 if (symtab_shndx_hdr != NULL)
4586 {
4587 error (_("File contains multiple symtab shndx tables\n"));
4588 continue;
4589 }
4590 symtab_shndx_hdr = section;
4591 }
08d8fa11
JJ		 4592 else if (section->sh_type == SHT_SYMTAB)
4593 CHECK_ENTSIZE (section, i, Sym);
4594 else if (section->sh_type == SHT_GROUP)
4595 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4596 else if (section->sh_type == SHT_REL)
4597 CHECK_ENTSIZE (section, i, Rel);
4598 else if (section->sh_type == SHT_RELA)
4599 CHECK_ENTSIZE (section, i, Rela);
252b5132 4600 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4601 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4602 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4603 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4604 && (const_strneq (name, ".debug_")
4605 || const_strneq (name, ".zdebug_")))
252b5132 4606 {
1b315056
CS		 4607 if (name[1] == 'z')
4608 name += sizeof (".zdebug_") - 1;
4609 else
4610 name += sizeof (".debug_") - 1;
252b5132
RH		 4611
4612 if (do_debugging
18bd398b 4613 || (do_debug_info && streq (name, "info"))
2b6f5997 4614 || (do_debug_info && streq (name, "types"))
18bd398b 4615 || (do_debug_abbrevs && streq (name, "abbrev"))
4cb93e3b 4616 || (do_debug_lines && streq (name, "line"))
18bd398b 4617 || (do_debug_pubnames && streq (name, "pubnames"))
f9f0e732 4618 || (do_debug_pubtypes && streq (name, "pubtypes"))
18bd398b
NC		 4619 || (do_debug_aranges && streq (name, "aranges"))
4620 || (do_debug_ranges && streq (name, "ranges"))
4621 || (do_debug_frames && streq (name, "frame"))
4622 || (do_debug_macinfo && streq (name, "macinfo"))
4623 || (do_debug_str && streq (name, "str"))
4624 || (do_debug_loc && streq (name, "loc"))
252b5132 4625 )
09c11c86 4626 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4627 }
a262ae96 4628 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4629 else if ((do_debugging || do_debug_info)
0112cd26 4630 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4631 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4632 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4633 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4634 else if (do_gdb_index && streq (name, ".gdb_index"))
4635 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4636 /* Trace sections for Itanium VMS. */
4637 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4638 || do_trace_aranges)
4639 && const_strneq (name, ".trace_"))
4640 {
4641 name += sizeof (".trace_") - 1;
4642
4643 if (do_debugging
4644 || (do_trace_info && streq (name, "info"))
4645 || (do_trace_abbrevs && streq (name, "abbrev"))
4646 || (do_trace_aranges && streq (name, "aranges"))
4647 )
4648 request_dump_bynumber (i, DEBUG_DUMP);
4649 }
4650
252b5132
RH		 4651 }
4652
4653 if (! do_sections)
4654 return 1;
4655
3a1a2036
NC		 4656 if (elf_header.e_shnum > 1)
4657 printf (_("\nSection Headers:\n"));
4658 else
4659 printf (_("\nSection Header:\n"));
76da6bbe 4660
f7a99963 4661 if (is_32bit_elf)
595cf52e 4662 {
5477e8a0 4663 if (do_section_details)
595cf52e
L		 4664 {
4665 printf (_(" [Nr] Name\n"));
5477e8a0 4666 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4667 }
4668 else
4669 printf
4670 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4671 }
d974e256 4672 else if (do_wide)
595cf52e 4673 {
5477e8a0 4674 if (do_section_details)
595cf52e
L		 4675 {
4676 printf (_(" [Nr] Name\n"));
5477e8a0 4677 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4678 }
4679 else
4680 printf
4681 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4682 }
f7a99963
NC		 4683 else
4684 {
5477e8a0 4685 if (do_section_details)
595cf52e
L		 4686 {
4687 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4688 printf (_(" Type Address Offset Link\n"));
4689 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4690 }
4691 else
4692 {
4693 printf (_(" [Nr] Name Type Address Offset\n"));
4694 printf (_(" Size EntSize Flags Link Info Align\n"));
4695 }
f7a99963 4696 }
252b5132 4697
5477e8a0
L		 4698 if (do_section_details)
4699 printf (_(" Flags\n"));
4700
252b5132
RH		 4701 for (i = 0, section = section_headers;
4702 i < elf_header.e_shnum;
b34976b6 4703 i++, section++)
252b5132 4704 {
5477e8a0 4705 if (do_section_details)
595cf52e
L		 4706 {
4707 printf (" [%2u] %s\n",
4fbb74a6 4708 i,
595cf52e
L		 4709 SECTION_NAME (section));
4710 if (is_32bit_elf || do_wide)
4711 printf (" %-15.15s ",
4712 get_section_type_name (section->sh_type));
4713 }
4714 else
b9eb56c1
NC		 4715 printf ((do_wide ? " [%2u] %-17s %-15s "
4716 : " [%2u] %-17.17s %-15.15s "),
4fbb74a6 4717 i,
595cf52e
L		 4718 SECTION_NAME (section),
4719 get_section_type_name (section->sh_type));
252b5132 4720
f7a99963
NC		 4721 if (is_32bit_elf)
4722 {
cfcac11d
NC		 4723 const char * link_too_big = NULL;
4724
f7a99963 4725 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4726
f7a99963
NC		 4727 printf ( " %6.6lx %6.6lx %2.2lx",
4728 (unsigned long) section->sh_offset,
4729 (unsigned long) section->sh_size,
4730 (unsigned long) section->sh_entsize);
d1133906 4731
5477e8a0
L		 4732 if (do_section_details)
4733 fputs (" ", stdout);
4734 else
4735 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4736
cfcac11d
NC		 4737 if (section->sh_link >= elf_header.e_shnum)
4738 {
4739 link_too_big = "";
4740 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4741 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4742 switch (elf_header.e_machine)
4743 {
caa83f8b
NC		 4744 case EM_386:
4745 case EM_486:
4746 case EM_X86_64:
7f502d6c 4747 case EM_L1OM:
7a9068fe 4748 case EM_K1OM:
cfcac11d
NC		 4749 case EM_OLD_SPARCV9:
4750 case EM_SPARC32PLUS:
4751 case EM_SPARCV9:
4752 case EM_SPARC:
4753 if (section->sh_link == (SHN_BEFORE & 0xffff))
4754 link_too_big = "BEFORE";
4755 else if (section->sh_link == (SHN_AFTER & 0xffff))
4756 link_too_big = "AFTER";
4757 break;
4758 default:
4759 break;
4760 }
4761 }
4762
4763 if (do_section_details)
4764 {
4765 if (link_too_big != NULL && * link_too_big)
4766 printf ("<%s> ", link_too_big);
4767 else
4768 printf ("%2u ", section->sh_link);
4769 printf ("%3u %2lu\n", section->sh_info,
4770 (unsigned long) section->sh_addralign);
4771 }
4772 else
4773 printf ("%2u %3u %2lu\n",
4774 section->sh_link,
4775 section->sh_info,
4776 (unsigned long) section->sh_addralign);
4777
4778 if (link_too_big && ! * link_too_big)
4779 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4780 i, section->sh_link);
f7a99963 4781 }
d974e256
JJ		 4782 else if (do_wide)
4783 {
4784 print_vma (section->sh_addr, LONG_HEX);
4785
4786 if ((long) section->sh_offset == section->sh_offset)
4787 printf (" %6.6lx", (unsigned long) section->sh_offset);
4788 else
4789 {
4790 putchar (' ');
4791 print_vma (section->sh_offset, LONG_HEX);
4792 }
4793
4794 if ((unsigned long) section->sh_size == section->sh_size)
4795 printf (" %6.6lx", (unsigned long) section->sh_size);
4796 else
4797 {
4798 putchar (' ');
4799 print_vma (section->sh_size, LONG_HEX);
4800 }
4801
4802 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4803 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4804 else
4805 {
4806 putchar (' ');
4807 print_vma (section->sh_entsize, LONG_HEX);
4808 }
4809
5477e8a0
L		 4810 if (do_section_details)
4811 fputs (" ", stdout);
4812 else
4813 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4814
72de5009 4815 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4816
4817 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4818 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4819 else
4820 {
4821 print_vma (section->sh_addralign, DEC);
4822 putchar ('\n');
4823 }
4824 }
5477e8a0 4825 else if (do_section_details)
595cf52e 4826 {
5477e8a0 4827 printf (" %-15.15s ",
595cf52e 4828 get_section_type_name (section->sh_type));
595cf52e
L		 4829 print_vma (section->sh_addr, LONG_HEX);
4830 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4831 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4832 else
4833 {
4834 printf (" ");
4835 print_vma (section->sh_offset, LONG_HEX);
4836 }
72de5009 4837 printf (" %u\n ", section->sh_link);
595cf52e 4838 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4839 putchar (' ');
595cf52e
L		 4840 print_vma (section->sh_entsize, LONG_HEX);
4841
72de5009
AM		 4842 printf (" %-16u %lu\n",
4843 section->sh_info,
595cf52e
L		 4844 (unsigned long) section->sh_addralign);
4845 }
f7a99963
NC		 4846 else
4847 {
4848 putchar (' ');
4849 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4850 if ((long) section->sh_offset == section->sh_offset)
4851 printf (" %8.8lx", (unsigned long) section->sh_offset);
4852 else
4853 {
4854 printf (" ");
4855 print_vma (section->sh_offset, LONG_HEX);
4856 }
f7a99963
NC		 4857 printf ("\n ");
4858 print_vma (section->sh_size, LONG_HEX);
4859 printf (" ");
4860 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4861
d1133906 4862 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4863
72de5009
AM		 4864 printf (" %2u %3u %lu\n",
4865 section->sh_link,
4866 section->sh_info,
f7a99963
NC		 4867 (unsigned long) section->sh_addralign);
4868 }
5477e8a0
L		 4869
4870 if (do_section_details)
4871 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4872 }
4873
5477e8a0 4874 if (!do_section_details)
3dbcc61d
NC		 4875 {
4876 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 4877 || elf_header.e_machine == EM_L1OM
4878 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 4879 printf (_("Key to Flags:\n\
4880 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4881 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4882 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4883 else
4884 printf (_("Key to Flags:\n\
e3c8793a 4885 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4886 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4887 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4888 }
d1133906 4889
252b5132
RH		 4890 return 1;
4891}
4892
f5842774
L		 4893static const char *
4894get_group_flags (unsigned int flags)
4895{
4896 static char buff[32];
4897 switch (flags)
4898 {
220453ec
AM		 4899 case 0:
4900 return "";
4901
f5842774 4902 case GRP_COMDAT:
220453ec 4903 return "COMDAT ";
f5842774
L		 4904
4905 default:
220453ec 4906 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4907 break;
4908 }
4909 return buff;
4910}
4911
4912static int
2cf0635d 4913process_section_groups (FILE * file)
f5842774 4914{
2cf0635d 4915 Elf_Internal_Shdr * section;
f5842774 4916 unsigned int i;
2cf0635d
NC		 4917 struct group * group;
4918 Elf_Internal_Shdr * symtab_sec;
4919 Elf_Internal_Shdr * strtab_sec;
4920 Elf_Internal_Sym * symtab;
4921 char * strtab;
c256ffe7 4922 size_t strtab_size;
d1f5c6e3
L		 4923
4924 /* Don't process section groups unless needed. */
4925 if (!do_unwind && !do_section_groups)
4926 return 1;
f5842774
L		 4927
4928 if (elf_header.e_shnum == 0)
4929 {
4930 if (do_section_groups)
82f2dbf7 4931 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 4932
4933 return 1;
4934 }
4935
4936 if (section_headers == NULL)
4937 {
4938 error (_("Section headers are not available!\n"));
4939 abort ();
4940 }
4941
3f5e193b
NC		 4942 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4943 sizeof (struct group *));
e4b17d5c
L		 4944
4945 if (section_headers_groups == NULL)
4946 {
4947 error (_("Out of memory\n"));
4948 return 0;
4949 }
4950
f5842774 4951 /* Scan the sections for the group section. */
d1f5c6e3 4952 group_count = 0;
f5842774
L		 4953 for (i = 0, section = section_headers;
4954 i < elf_header.e_shnum;
4955 i++, section++)
e4b17d5c
L		 4956 if (section->sh_type == SHT_GROUP)
4957 group_count++;
4958
d1f5c6e3
L		 4959 if (group_count == 0)
4960 {
4961 if (do_section_groups)
4962 printf (_("\nThere are no section groups in this file.\n"));
4963
4964 return 1;
4965 }
4966
3f5e193b 4967 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 4968
4969 if (section_groups == NULL)
4970 {
4971 error (_("Out of memory\n"));
4972 return 0;
4973 }
4974
d1f5c6e3
L		 4975 symtab_sec = NULL;
4976 strtab_sec = NULL;
4977 symtab = NULL;
4978 strtab = NULL;
c256ffe7 4979 strtab_size = 0;
e4b17d5c
L		 4980 for (i = 0, section = section_headers, group = section_groups;
4981 i < elf_header.e_shnum;
4982 i++, section++)
f5842774
L		 4983 {
4984 if (section->sh_type == SHT_GROUP)
4985 {
2cf0635d
NC		 4986 char * name = SECTION_NAME (section);
4987 char * group_name;
4988 unsigned char * start;
4989 unsigned char * indices;
f5842774 4990 unsigned int entry, j, size;
2cf0635d
NC		 4991 Elf_Internal_Shdr * sec;
4992 Elf_Internal_Sym * sym;
f5842774
L		 4993
4994 /* Get the symbol table. */
4fbb74a6
AM		 4995 if (section->sh_link >= elf_header.e_shnum
4996 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 4997 != SHT_SYMTAB))
f5842774
L		 4998 {
4999 error (_("Bad sh_link in group section `%s'\n"), name);
5000 continue;
5001 }
d1f5c6e3
L		 5002
5003 if (symtab_sec != sec)
5004 {
5005 symtab_sec = sec;
5006 if (symtab)
5007 free (symtab);
5008 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
5009 }
f5842774 5010
dd24e3da
NC		 5011 if (symtab == NULL)
5012 {
5013 error (_("Corrupt header in group section `%s'\n"), name);
5014 continue;
5015 }
5016
f5842774
L		 5017 sym = symtab + section->sh_info;
5018
5019 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5020 {
4fbb74a6
AM		 5021 if (sym->st_shndx == 0
5022 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5023 {
5024 error (_("Bad sh_info in group section `%s'\n"), name);
5025 continue;
5026 }
ba2685cc 5027
4fbb74a6 5028 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5029 strtab_sec = NULL;
5030 if (strtab)
5031 free (strtab);
f5842774 5032 strtab = NULL;
c256ffe7 5033 strtab_size = 0;
f5842774
L		 5034 }
5035 else
5036 {
5037 /* Get the string table. */
4fbb74a6 5038 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5039 {
5040 strtab_sec = NULL;
5041 if (strtab)
5042 free (strtab);
5043 strtab = NULL;
5044 strtab_size = 0;
5045 }
5046 else if (strtab_sec
4fbb74a6 5047 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5048 {
5049 strtab_sec = sec;
5050 if (strtab)
5051 free (strtab);
3f5e193b
NC		 5052 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5053 1, strtab_sec->sh_size,
5054 _("string table"));
c256ffe7 5055 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5056 }
c256ffe7 5057 group_name = sym->st_name < strtab_size
2b692964 5058 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5059 }
5060
3f5e193b
NC		 5061 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5062 1, section->sh_size,
5063 _("section data"));
59245841
NC		 5064 if (start == NULL)
5065 continue;
f5842774
L		 5066
5067 indices = start;
5068 size = (section->sh_size / section->sh_entsize) - 1;
5069 entry = byte_get (indices, 4);
5070 indices += 4;
e4b17d5c
L		 5071
5072 if (do_section_groups)
5073 {
2b692964 5074 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5075 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5076
e4b17d5c
L		 5077 printf (_(" [Index] Name\n"));
5078 }
5079
5080 group->group_index = i;
5081
f5842774
L		 5082 for (j = 0; j < size; j++)
5083 {
2cf0635d 5084 struct group_list * g;
e4b17d5c 5085
f5842774
L		 5086 entry = byte_get (indices, 4);
5087 indices += 4;
5088
4fbb74a6 5089 if (entry >= elf_header.e_shnum)
391cb864
L		 5090 {
5091 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5092 entry, i, elf_header.e_shnum - 1);
5093 continue;
5094 }
391cb864 5095
4fbb74a6 5096 if (section_headers_groups [entry] != NULL)
e4b17d5c 5097 {
d1f5c6e3
L		 5098 if (entry)
5099 {
391cb864
L		 5100 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5101 entry, i,
4fbb74a6 5102 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5103 continue;
5104 }
5105 else
5106 {
5107 /* Intel C/C++ compiler may put section 0 in a
5108 section group. We just warn it the first time
5109 and ignore it afterwards. */
5110 static int warned = 0;
5111 if (!warned)
5112 {
5113 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5114 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5115 warned++;
5116 }
5117 }
e4b17d5c
L		 5118 }
5119
4fbb74a6 5120 section_headers_groups [entry] = group;
e4b17d5c
L		 5121
5122 if (do_section_groups)
5123 {
4fbb74a6 5124 sec = section_headers + entry;
c256ffe7 5125 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5126 }
5127
3f5e193b 5128 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5129 g->section_index = entry;
5130 g->next = group->root;
5131 group->root = g;
f5842774
L		 5132 }
5133
f5842774
L		 5134 if (start)
5135 free (start);
e4b17d5c
L		 5136
5137 group++;
f5842774
L		 5138 }
5139 }
5140
d1f5c6e3
L		 5141 if (symtab)
5142 free (symtab);
5143 if (strtab)
5144 free (strtab);
f5842774
L		 5145 return 1;
5146}
5147
28f997cf
TG		 5148/* Data used to display dynamic fixups. */
5149
5150struct ia64_vms_dynfixup
5151{
5152 bfd_vma needed_ident; /* Library ident number. */
5153 bfd_vma needed; /* Index in the dstrtab of the library name. */
5154 bfd_vma fixup_needed; /* Index of the library. */
5155 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5156 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5157};
5158
5159/* Data used to display dynamic relocations. */
5160
5161struct ia64_vms_dynimgrela
5162{
5163 bfd_vma img_rela_cnt; /* Number of relocations. */
5164 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5165};
5166
5167/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5168 library). */
5169
5170static void
5171dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5172 const char *strtab, unsigned int strtab_sz)
5173{
5174 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5175 long i;
5176 const char *lib_name;
5177
5178 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5179 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5180 _("dynamic section image fixups"));
5181 if (!imfs)
5182 return;
5183
5184 if (fixup->needed < strtab_sz)
5185 lib_name = strtab + fixup->needed;
5186 else
5187 {
5188 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5189 (unsigned long) fixup->needed);
28f997cf
TG		 5190 lib_name = "???";
5191 }
5192 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5193 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5194 printf
5195 (_("Seg Offset Type SymVec DataType\n"));
5196
5197 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5198 {
5199 unsigned int type;
5200 const char *rtype;
5201
5202 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5203 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5204 type = BYTE_GET (imfs [i].type);
5205 rtype = elf_ia64_reloc_type (type);
5206 if (rtype == NULL)
5207 printf (" 0x%08x ", type);
5208 else
5209 printf (" %-32s ", rtype);
5210 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5211 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5212 }
5213
5214 free (imfs);
5215}
5216
5217/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5218
5219static void
5220dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5221{
5222 Elf64_External_VMS_IMAGE_RELA *imrs;
5223 long i;
5224
5225 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5226 1, imgrela->img_rela_cnt * sizeof (*imrs),
5227 _("dynamic section image relas"));
5228 if (!imrs)
5229 return;
5230
5231 printf (_("\nImage relocs\n"));
5232 printf
5233 (_("Seg Offset Type Addend Seg Sym Off\n"));
5234
5235 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5236 {
5237 unsigned int type;
5238 const char *rtype;
5239
5240 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5241 printf ("%08" BFD_VMA_FMT "x ",
5242 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5243 type = BYTE_GET (imrs [i].type);
5244 rtype = elf_ia64_reloc_type (type);
5245 if (rtype == NULL)
5246 printf ("0x%08x ", type);
5247 else
5248 printf ("%-31s ", rtype);
5249 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5250 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5251 printf ("%08" BFD_VMA_FMT "x\n",
5252 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5253 }
5254
5255 free (imrs);
5256}
5257
5258/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5259
5260static int
5261process_ia64_vms_dynamic_relocs (FILE *file)
5262{
5263 struct ia64_vms_dynfixup fixup;
5264 struct ia64_vms_dynimgrela imgrela;
5265 Elf_Internal_Dyn *entry;
5266 int res = 0;
5267 bfd_vma strtab_off = 0;
5268 bfd_vma strtab_sz = 0;
5269 char *strtab = NULL;
5270
5271 memset (&fixup, 0, sizeof (fixup));
5272 memset (&imgrela, 0, sizeof (imgrela));
5273
5274 /* Note: the order of the entries is specified by the OpenVMS specs. */
5275 for (entry = dynamic_section;
5276 entry < dynamic_section + dynamic_nent;
5277 entry++)
5278 {
5279 switch (entry->d_tag)
5280 {
5281 case DT_IA_64_VMS_STRTAB_OFFSET:
5282 strtab_off = entry->d_un.d_val;
5283 break;
5284 case DT_STRSZ:
5285 strtab_sz = entry->d_un.d_val;
5286 if (strtab == NULL)
5287 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5288 1, strtab_sz, _("dynamic string section"));
5289 break;
5290
5291 case DT_IA_64_VMS_NEEDED_IDENT:
5292 fixup.needed_ident = entry->d_un.d_val;
5293 break;
5294 case DT_NEEDED:
5295 fixup.needed = entry->d_un.d_val;
5296 break;
5297 case DT_IA_64_VMS_FIXUP_NEEDED:
5298 fixup.fixup_needed = entry->d_un.d_val;
5299 break;
5300 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5301 fixup.fixup_rela_cnt = entry->d_un.d_val;
5302 break;
5303 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5304 fixup.fixup_rela_off = entry->d_un.d_val;
5305 res++;
5306 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5307 break;
5308
5309 case DT_IA_64_VMS_IMG_RELA_CNT:
5310 imgrela.img_rela_cnt = entry->d_un.d_val;
5311 break;
5312 case DT_IA_64_VMS_IMG_RELA_OFF:
5313 imgrela.img_rela_off = entry->d_un.d_val;
5314 res++;
5315 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5316 break;
5317
5318 default:
5319 break;
5320 }
5321 }
5322
5323 if (strtab != NULL)
5324 free (strtab);
5325
5326 return res;
5327}
5328
85b1c36d 5329static struct
566b0d53 5330{
2cf0635d 5331 const char * name;
566b0d53
L		 5332 int reloc;
5333 int size;
5334 int rela;
5335} dynamic_relocations [] =
5336{
5337 { "REL", DT_REL, DT_RELSZ, FALSE },
5338 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5339 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5340};
5341
252b5132 5342/* Process the reloc section. */
18bd398b 5343
252b5132 5344static int
2cf0635d 5345process_relocs (FILE * file)
252b5132 5346{
b34976b6
AM		 5347 unsigned long rel_size;
5348 unsigned long rel_offset;
252b5132
RH		 5349
5350
5351 if (!do_reloc)
5352 return 1;
5353
5354 if (do_using_dynamic)
5355 {
566b0d53 5356 int is_rela;
2cf0635d 5357 const char * name;
566b0d53
L		 5358 int has_dynamic_reloc;
5359 unsigned int i;
0de14b54 5360
566b0d53 5361 has_dynamic_reloc = 0;
252b5132 5362
566b0d53 5363 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5364 {
566b0d53
L		 5365 is_rela = dynamic_relocations [i].rela;
5366 name = dynamic_relocations [i].name;
5367 rel_size = dynamic_info [dynamic_relocations [i].size];
5368 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5369
566b0d53
L		 5370 has_dynamic_reloc |= rel_size;
5371
5372 if (is_rela == UNKNOWN)
aa903cfb 5373 {
566b0d53
L		 5374 if (dynamic_relocations [i].reloc == DT_JMPREL)
5375 switch (dynamic_info[DT_PLTREL])
5376 {
5377 case DT_REL:
5378 is_rela = FALSE;
5379 break;
5380 case DT_RELA:
5381 is_rela = TRUE;
5382 break;
5383 }
aa903cfb 5384 }
252b5132 5385
566b0d53
L		 5386 if (rel_size)
5387 {
5388 printf
5389 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5390 name, rel_offset, rel_size);
252b5132 5391
d93f0186
NC		 5392 dump_relocations (file,
5393 offset_from_vma (file, rel_offset, rel_size),
5394 rel_size,
566b0d53 5395 dynamic_symbols, num_dynamic_syms,
d79b3d50 5396 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5397 }
252b5132 5398 }
566b0d53 5399
28f997cf
TG		 5400 if (is_ia64_vms ())
5401 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5402
566b0d53 5403 if (! has_dynamic_reloc)
252b5132
RH		 5404 printf (_("\nThere are no dynamic relocations in this file.\n"));
5405 }
5406 else
5407 {
2cf0635d 5408 Elf_Internal_Shdr * section;
b34976b6
AM		 5409 unsigned long i;
5410 int found = 0;
252b5132
RH		 5411
5412 for (i = 0, section = section_headers;
5413 i < elf_header.e_shnum;
b34976b6 5414 i++, section++)
252b5132
RH		 5415 {
5416 if ( section->sh_type != SHT_RELA
5417 && section->sh_type != SHT_REL)
5418 continue;
5419
5420 rel_offset = section->sh_offset;
5421 rel_size = section->sh_size;
5422
5423 if (rel_size)
5424 {
2cf0635d 5425 Elf_Internal_Shdr * strsec;
b34976b6 5426 int is_rela;
103f02d3 5427
252b5132
RH		 5428 printf (_("\nRelocation section "));
5429
5430 if (string_table == NULL)
19936277 5431 printf ("%d", section->sh_name);
252b5132 5432 else
3a1a2036 5433 printf (_("'%s'"), SECTION_NAME (section));
252b5132
RH		 5434
5435 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5436 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5437
d79b3d50
NC		 5438 is_rela = section->sh_type == SHT_RELA;
5439
4fbb74a6
AM		 5440 if (section->sh_link != 0
5441 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5442 {
2cf0635d
NC		 5443 Elf_Internal_Shdr * symsec;
5444 Elf_Internal_Sym * symtab;
d79b3d50 5445 unsigned long nsyms;
c256ffe7 5446 unsigned long strtablen = 0;
2cf0635d 5447 char * strtab = NULL;
57346661 5448
4fbb74a6 5449 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5450 if (symsec->sh_type != SHT_SYMTAB
5451 && symsec->sh_type != SHT_DYNSYM)
5452 continue;
5453
af3fc3bc 5454 nsyms = symsec->sh_size / symsec->sh_entsize;
9ad5cbcf 5455 symtab = GET_ELF_SYMBOLS (file, symsec);
252b5132 5456
af3fc3bc
AM		 5457 if (symtab == NULL)
5458 continue;
252b5132 5459
4fbb74a6
AM		 5460 if (symsec->sh_link != 0
5461 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5462 {
4fbb74a6 5463 strsec = section_headers + symsec->sh_link;
103f02d3 5464
3f5e193b
NC		 5465 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5466 1, strsec->sh_size,
5467 _("string table"));
c256ffe7
JJ		 5468 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5469 }
252b5132 5470
d79b3d50
NC		 5471 dump_relocations (file, rel_offset, rel_size,
5472 symtab, nsyms, strtab, strtablen, is_rela);
5473 if (strtab)
5474 free (strtab);
5475 free (symtab);
5476 }
5477 else
5478 dump_relocations (file, rel_offset, rel_size,
5479 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5480
5481 found = 1;
5482 }
5483 }
5484
5485 if (! found)
5486 printf (_("\nThere are no relocations in this file.\n"));
5487 }
5488
5489 return 1;
5490}
5491
57346661
AM		 5492/* Process the unwind section. */
5493
4d6ed7c8
NC		 5494#include "unwind-ia64.h"
5495
5496/* An absolute address consists of a section and an offset. If the
5497 section is NULL, the offset itself is the address, otherwise, the
5498 address equals to LOAD_ADDRESS(section) + offset. */
5499
5500struct absaddr
5501 {
5502 unsigned short section;
5503 bfd_vma offset;
5504 };
5505
1949de15
L		 5506#define ABSADDR(a) \
5507 ((a).section \
5508 ? section_headers [(a).section].sh_addr + (a).offset \
5509 : (a).offset)
5510
3f5e193b
NC		 5511struct ia64_unw_table_entry
5512 {
5513 struct absaddr start;
5514 struct absaddr end;
5515 struct absaddr info;
5516 };
5517
57346661 5518struct ia64_unw_aux_info
4d6ed7c8 5519 {
3f5e193b
NC		 5520
5521 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5522 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5523 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5524 unsigned long info_size; /* Size of unwind info. */
5525 bfd_vma info_addr; /* starting address of unwind info. */
5526 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5527 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5528 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5529 char * strtab; /* The string table. */
b34976b6 5530 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5531 };
5532
4d6ed7c8 5533static void
2cf0635d 5534find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5535 unsigned long nsyms,
2cf0635d 5536 const char * strtab,
57346661 5537 unsigned long strtab_size,
d3ba0551 5538 struct absaddr addr,
2cf0635d
NC		 5539 const char ** symname,
5540 bfd_vma * offset)
4d6ed7c8 5541{
d3ba0551 5542 bfd_vma dist = 0x100000;
2cf0635d
NC		 5543 Elf_Internal_Sym * sym;
5544 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5545 unsigned long i;
5546
0b6ae522
DJ		 5547 REMOVE_ARCH_BITS (addr.offset);
5548
57346661 5549 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5550 {
0b6ae522
DJ		 5551 bfd_vma value = sym->st_value;
5552
5553 REMOVE_ARCH_BITS (value);
5554
4d6ed7c8
NC		 5555 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5556 && sym->st_name != 0
5557 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5558 && addr.offset >= value
5559 && addr.offset - value < dist)
4d6ed7c8
NC		 5560 {
5561 best = sym;
0b6ae522 5562 dist = addr.offset - value;
4d6ed7c8
NC		 5563 if (!dist)
5564 break;
5565 }
5566 }
5567 if (best)
5568 {
57346661 5569 *symname = (best->st_name >= strtab_size
2b692964 5570 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5571 *offset = dist;
5572 return;
5573 }
5574 *symname = NULL;
5575 *offset = addr.offset;
5576}
5577
5578static void
2cf0635d 5579dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5580{
2cf0635d 5581 struct ia64_unw_table_entry * tp;
4d6ed7c8 5582 int in_body;
7036c0e1 5583
4d6ed7c8
NC		 5584 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5585 {
5586 bfd_vma stamp;
5587 bfd_vma offset;
2cf0635d
NC		 5588 const unsigned char * dp;
5589 const unsigned char * head;
5590 const char * procname;
4d6ed7c8 5591
57346661
AM		 5592 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5593 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5594
5595 fputs ("\n<", stdout);
5596
5597 if (procname)
5598 {
5599 fputs (procname, stdout);
5600
5601 if (offset)
5602 printf ("+%lx", (unsigned long) offset);
5603 }
5604
5605 fputs (">: [", stdout);
5606 print_vma (tp->start.offset, PREFIX_HEX);
5607 fputc ('-', stdout);
5608 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5609 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5610 (unsigned long) (tp->info.offset - aux->seg_base));
5611
1949de15 5612 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5613 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5614
86f55779 5615 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5616 (unsigned) UNW_VER (stamp),
5617 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5618 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5619 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5620 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5621
5622 if (UNW_VER (stamp) != 1)
5623 {
2b692964 5624 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5625 continue;
5626 }
5627
5628 in_body = 0;
89fac5e3 5629 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5630 dp = unw_decode (dp, in_body, & in_body);
5631 }
5632}
5633
5634static int
2cf0635d
NC		 5635slurp_ia64_unwind_table (FILE * file,
5636 struct ia64_unw_aux_info * aux,
5637 Elf_Internal_Shdr * sec)
4d6ed7c8 5638{
89fac5e3 5639 unsigned long size, nrelas, i;
2cf0635d
NC		 5640 Elf_Internal_Phdr * seg;
5641 struct ia64_unw_table_entry * tep;
5642 Elf_Internal_Shdr * relsec;
5643 Elf_Internal_Rela * rela;
5644 Elf_Internal_Rela * rp;
5645 unsigned char * table;
5646 unsigned char * tp;
5647 Elf_Internal_Sym * sym;
5648 const char * relname;
4d6ed7c8 5649
4d6ed7c8
NC		 5650 /* First, find the starting address of the segment that includes
5651 this section: */
5652
5653 if (elf_header.e_phnum)
5654 {
d93f0186 5655 if (! get_program_headers (file))
4d6ed7c8 5656 return 0;
4d6ed7c8 5657
d93f0186
NC		 5658 for (seg = program_headers;
5659 seg < program_headers + elf_header.e_phnum;
5660 ++seg)
4d6ed7c8
NC		 5661 {
5662 if (seg->p_type != PT_LOAD)
5663 continue;
5664
5665 if (sec->sh_addr >= seg->p_vaddr
5666 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5667 {
5668 aux->seg_base = seg->p_vaddr;
5669 break;
5670 }
5671 }
4d6ed7c8
NC		 5672 }
5673
5674 /* Second, build the unwind table from the contents of the unwind section: */
5675 size = sec->sh_size;
3f5e193b
NC		 5676 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5677 _("unwind table"));
a6e9f9df
AM		 5678 if (!table)
5679 return 0;
4d6ed7c8 5680
3f5e193b
NC		 5681 aux->table = (struct ia64_unw_table_entry *)
5682 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5683 tep = aux->table;
c6a0c689 5684 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5685 {
5686 tep->start.section = SHN_UNDEF;
5687 tep->end.section = SHN_UNDEF;
5688 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5689 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5690 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5691 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5692 tep->start.offset += aux->seg_base;
5693 tep->end.offset += aux->seg_base;
5694 tep->info.offset += aux->seg_base;
5695 }
5696 free (table);
5697
41e92641 5698 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5699 for (relsec = section_headers;
5700 relsec < section_headers + elf_header.e_shnum;
5701 ++relsec)
5702 {
5703 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5704 || relsec->sh_info >= elf_header.e_shnum
5705 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5706 continue;
5707
5708 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5709 & rela, & nrelas))
5710 return 0;
5711
5712 for (rp = rela; rp < rela + nrelas; ++rp)
5713 {
aca88567
NC		 5714 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5715 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5716
0112cd26 5717 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5718 {
e5fb9629 5719 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5720 continue;
5721 }
5722
89fac5e3 5723 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5724
89fac5e3 5725 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5726 {
5727 case 0:
5728 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5729 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5730 break;
5731 case 1:
5732 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5733 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5734 break;
5735 case 2:
5736 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5737 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5738 break;
5739 default:
5740 break;
5741 }
5742 }
5743
5744 free (rela);
5745 }
5746
89fac5e3 5747 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5748 return 1;
5749}
5750
5751static int
2cf0635d 5752ia64_process_unwind (FILE * file)
4d6ed7c8 5753{
2cf0635d
NC		 5754 Elf_Internal_Shdr * sec;
5755 Elf_Internal_Shdr * unwsec = NULL;
5756 Elf_Internal_Shdr * strsec;
89fac5e3 5757 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5758 struct ia64_unw_aux_info aux;
f1467e33 5759
4d6ed7c8
NC		 5760 memset (& aux, 0, sizeof (aux));
5761
4d6ed7c8
NC		 5762 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5763 {
c256ffe7 5764 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5765 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8
NC		 5766 {
5767 aux.nsyms = sec->sh_size / sec->sh_entsize;
9ad5cbcf 5768 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4d6ed7c8 5769
4fbb74a6 5770 strsec = section_headers + sec->sh_link;
59245841 5771 assert (aux.strtab == NULL);
3f5e193b
NC		 5772 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5773 1, strsec->sh_size,
5774 _("string table"));
c256ffe7 5775 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5776 }
5777 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5778 unwcount++;
5779 }
5780
5781 if (!unwcount)
5782 printf (_("\nThere are no unwind sections in this file.\n"));
5783
5784 while (unwcount-- > 0)
5785 {
2cf0635d 5786 char * suffix;
579f31ac
JJ		 5787 size_t len, len2;
5788
5789 for (i = unwstart, sec = section_headers + unwstart;
5790 i < elf_header.e_shnum; ++i, ++sec)
5791 if (sec->sh_type == SHT_IA_64_UNWIND)
5792 {
5793 unwsec = sec;
5794 break;
5795 }
5796
5797 unwstart = i + 1;
5798 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5799
e4b17d5c
L		 5800 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5801 {
5802 /* We need to find which section group it is in. */
2cf0635d 5803 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5804
5805 for (; g != NULL; g = g->next)
5806 {
4fbb74a6 5807 sec = section_headers + g->section_index;
18bd398b
NC		 5808
5809 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5810 break;
e4b17d5c
L		 5811 }
5812
5813 if (g == NULL)
5814 i = elf_header.e_shnum;
5815 }
18bd398b 5816 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5817 {
18bd398b 5818 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5819 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5820 suffix = SECTION_NAME (unwsec) + len;
5821 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5822 ++i, ++sec)
18bd398b
NC		 5823 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5824 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5825 break;
5826 }
5827 else
5828 {
5829 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5830 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5831 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5832 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5833 suffix = "";
18bd398b 5834 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5835 suffix = SECTION_NAME (unwsec) + len;
5836 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5837 ++i, ++sec)
18bd398b
NC		 5838 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5839 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5840 break;
5841 }
5842
5843 if (i == elf_header.e_shnum)
5844 {
5845 printf (_("\nCould not find unwind info section for "));
5846
5847 if (string_table == NULL)
5848 printf ("%d", unwsec->sh_name);
5849 else
3a1a2036 5850 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5851 }
5852 else
4d6ed7c8 5853 {
4d6ed7c8 5854 aux.info_addr = sec->sh_addr;
3f5e193b 5855 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5856 sec->sh_size,
3f5e193b 5857 _("unwind info"));
59245841 5858 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5859
579f31ac 5860 printf (_("\nUnwind section "));
4d6ed7c8 5861
579f31ac
JJ		 5862 if (string_table == NULL)
5863 printf ("%d", unwsec->sh_name);
5864 else
3a1a2036 5865 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5866
579f31ac 5867 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5868 (unsigned long) unwsec->sh_offset,
89fac5e3 5869 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5870
579f31ac 5871 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5872
579f31ac
JJ		 5873 if (aux.table_len > 0)
5874 dump_ia64_unwind (& aux);
5875
5876 if (aux.table)
5877 free ((char *) aux.table);
5878 if (aux.info)
5879 free ((char *) aux.info);
5880 aux.table = NULL;
5881 aux.info = NULL;
5882 }
4d6ed7c8 5883 }
4d6ed7c8 5884
4d6ed7c8
NC		 5885 if (aux.symtab)
5886 free (aux.symtab);
5887 if (aux.strtab)
5888 free ((char *) aux.strtab);
5889
5890 return 1;
5891}
5892
3f5e193b
NC		 5893struct hppa_unw_table_entry
5894 {
5895 struct absaddr start;
5896 struct absaddr end;
5897 unsigned int Cannot_unwind:1; /* 0 */
5898 unsigned int Millicode:1; /* 1 */
5899 unsigned int Millicode_save_sr0:1; /* 2 */
5900 unsigned int Region_description:2; /* 3..4 */
5901 unsigned int reserved1:1; /* 5 */
5902 unsigned int Entry_SR:1; /* 6 */
5903 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5904 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5905 unsigned int Args_stored:1; /* 16 */
5906 unsigned int Variable_Frame:1; /* 17 */
5907 unsigned int Separate_Package_Body:1; /* 18 */
5908 unsigned int Frame_Extension_Millicode:1; /* 19 */
5909 unsigned int Stack_Overflow_Check:1; /* 20 */
5910 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5911 unsigned int Ada_Region:1; /* 22 */
5912 unsigned int cxx_info:1; /* 23 */
5913 unsigned int cxx_try_catch:1; /* 24 */
5914 unsigned int sched_entry_seq:1; /* 25 */
5915 unsigned int reserved2:1; /* 26 */
5916 unsigned int Save_SP:1; /* 27 */
5917 unsigned int Save_RP:1; /* 28 */
5918 unsigned int Save_MRP_in_frame:1; /* 29 */
5919 unsigned int extn_ptr_defined:1; /* 30 */
5920 unsigned int Cleanup_defined:1; /* 31 */
5921
5922 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5923 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5924 unsigned int Large_frame:1; /* 2 */
5925 unsigned int Pseudo_SP_Set:1; /* 3 */
5926 unsigned int reserved4:1; /* 4 */
5927 unsigned int Total_frame_size:27; /* 5..31 */
5928 };
5929
57346661
AM		 5930struct hppa_unw_aux_info
5931 {
3f5e193b 5932 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 5933 unsigned long table_len; /* Length of unwind table. */
5934 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5935 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 5936 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5937 char * strtab; /* The string table. */
57346661
AM		 5938 unsigned long strtab_size; /* Size of string table. */
5939 };
5940
5941static void
2cf0635d 5942dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 5943{
2cf0635d 5944 struct hppa_unw_table_entry * tp;
57346661 5945
57346661
AM		 5946 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5947 {
5948 bfd_vma offset;
2cf0635d 5949 const char * procname;
57346661
AM		 5950
5951 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5952 aux->strtab_size, tp->start, &procname,
5953 &offset);
5954
5955 fputs ("\n<", stdout);
5956
5957 if (procname)
5958 {
5959 fputs (procname, stdout);
5960
5961 if (offset)
5962 printf ("+%lx", (unsigned long) offset);
5963 }
5964
5965 fputs (">: [", stdout);
5966 print_vma (tp->start.offset, PREFIX_HEX);
5967 fputc ('-', stdout);
5968 print_vma (tp->end.offset, PREFIX_HEX);
5969 printf ("]\n\t");
5970
18bd398b
NC		 5971#define PF(_m) if (tp->_m) printf (#_m " ");
5972#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 5973 PF(Cannot_unwind);
5974 PF(Millicode);
5975 PF(Millicode_save_sr0);
18bd398b 5976 /* PV(Region_description); */
57346661
AM		 5977 PF(Entry_SR);
5978 PV(Entry_FR);
5979 PV(Entry_GR);
5980 PF(Args_stored);
5981 PF(Variable_Frame);
5982 PF(Separate_Package_Body);
5983 PF(Frame_Extension_Millicode);
5984 PF(Stack_Overflow_Check);
5985 PF(Two_Instruction_SP_Increment);
5986 PF(Ada_Region);
5987 PF(cxx_info);
5988 PF(cxx_try_catch);
5989 PF(sched_entry_seq);
5990 PF(Save_SP);
5991 PF(Save_RP);
5992 PF(Save_MRP_in_frame);
5993 PF(extn_ptr_defined);
5994 PF(Cleanup_defined);
5995 PF(MPE_XL_interrupt_marker);
5996 PF(HP_UX_interrupt_marker);
5997 PF(Large_frame);
5998 PF(Pseudo_SP_Set);
5999 PV(Total_frame_size);
6000#undef PF
6001#undef PV
6002 }
6003
18bd398b 6004 printf ("\n");
57346661
AM		 6005}
6006
6007static int
2cf0635d
NC		 6008slurp_hppa_unwind_table (FILE * file,
6009 struct hppa_unw_aux_info * aux,
6010 Elf_Internal_Shdr * sec)
57346661 6011{
1c0751b2 6012 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6013 Elf_Internal_Phdr * seg;
6014 struct hppa_unw_table_entry * tep;
6015 Elf_Internal_Shdr * relsec;
6016 Elf_Internal_Rela * rela;
6017 Elf_Internal_Rela * rp;
6018 unsigned char * table;
6019 unsigned char * tp;
6020 Elf_Internal_Sym * sym;
6021 const char * relname;
57346661 6022
57346661
AM		 6023 /* First, find the starting address of the segment that includes
6024 this section. */
6025
6026 if (elf_header.e_phnum)
6027 {
6028 if (! get_program_headers (file))
6029 return 0;
6030
6031 for (seg = program_headers;
6032 seg < program_headers + elf_header.e_phnum;
6033 ++seg)
6034 {
6035 if (seg->p_type != PT_LOAD)
6036 continue;
6037
6038 if (sec->sh_addr >= seg->p_vaddr
6039 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6040 {
6041 aux->seg_base = seg->p_vaddr;
6042 break;
6043 }
6044 }
6045 }
6046
6047 /* Second, build the unwind table from the contents of the unwind
6048 section. */
6049 size = sec->sh_size;
3f5e193b
NC		 6050 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6051 _("unwind table"));
57346661
AM		 6052 if (!table)
6053 return 0;
6054
1c0751b2
DA		 6055 unw_ent_size = 16;
6056 nentries = size / unw_ent_size;
6057 size = unw_ent_size * nentries;
57346661 6058
3f5e193b
NC		 6059 tep = aux->table = (struct hppa_unw_table_entry *)
6060 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6061
1c0751b2 6062 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6063 {
6064 unsigned int tmp1, tmp2;
6065
6066 tep->start.section = SHN_UNDEF;
6067 tep->end.section = SHN_UNDEF;
6068
1c0751b2
DA		 6069 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6070 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6071 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6072 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6073
6074 tep->start.offset += aux->seg_base;
6075 tep->end.offset += aux->seg_base;
57346661
AM		 6076
6077 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6078 tep->Millicode = (tmp1 >> 30) & 0x1;
6079 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6080 tep->Region_description = (tmp1 >> 27) & 0x3;
6081 tep->reserved1 = (tmp1 >> 26) & 0x1;
6082 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6083 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6084 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6085 tep->Args_stored = (tmp1 >> 15) & 0x1;
6086 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6087 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6088 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6089 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6090 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6091 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6092 tep->cxx_info = (tmp1 >> 8) & 0x1;
6093 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6094 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6095 tep->reserved2 = (tmp1 >> 5) & 0x1;
6096 tep->Save_SP = (tmp1 >> 4) & 0x1;
6097 tep->Save_RP = (tmp1 >> 3) & 0x1;
6098 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6099 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6100 tep->Cleanup_defined = tmp1 & 0x1;
6101
6102 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6103 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6104 tep->Large_frame = (tmp2 >> 29) & 0x1;
6105 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6106 tep->reserved4 = (tmp2 >> 27) & 0x1;
6107 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6108 }
6109 free (table);
6110
6111 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6112 for (relsec = section_headers;
6113 relsec < section_headers + elf_header.e_shnum;
6114 ++relsec)
6115 {
6116 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6117 || relsec->sh_info >= elf_header.e_shnum
6118 || section_headers + relsec->sh_info != sec)
57346661
AM		 6119 continue;
6120
6121 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6122 & rela, & nrelas))
6123 return 0;
6124
6125 for (rp = rela; rp < rela + nrelas; ++rp)
6126 {
aca88567
NC		 6127 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6128 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6129
6130 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6131 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6132 {
6133 warn (_("Skipping unexpected relocation type %s\n"), relname);
6134 continue;
6135 }
6136
6137 i = rp->r_offset / unw_ent_size;
6138
89fac5e3 6139 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6140 {
6141 case 0:
6142 aux->table[i].start.section = sym->st_shndx;
1e456d54 6143 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6144 break;
6145 case 1:
6146 aux->table[i].end.section = sym->st_shndx;
1e456d54 6147 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6148 break;
6149 default:
6150 break;
6151 }
6152 }
6153
6154 free (rela);
6155 }
6156
1c0751b2 6157 aux->table_len = nentries;
57346661
AM		 6158
6159 return 1;
6160}
6161
6162static int
2cf0635d 6163hppa_process_unwind (FILE * file)
57346661 6164{
57346661 6165 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6166 Elf_Internal_Shdr * unwsec = NULL;
6167 Elf_Internal_Shdr * strsec;
6168 Elf_Internal_Shdr * sec;
18bd398b 6169 unsigned long i;
57346661
AM		 6170
6171 memset (& aux, 0, sizeof (aux));
6172
c256ffe7
JJ		 6173 if (string_table == NULL)
6174 return 1;
57346661
AM		 6175
6176 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6177 {
c256ffe7 6178 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6179 && sec->sh_link < elf_header.e_shnum)
57346661
AM		 6180 {
6181 aux.nsyms = sec->sh_size / sec->sh_entsize;
6182 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6183
4fbb74a6 6184 strsec = section_headers + sec->sh_link;
59245841 6185 assert (aux.strtab == NULL);
3f5e193b
NC		 6186 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6187 1, strsec->sh_size,
6188 _("string table"));
c256ffe7 6189 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6190 }
18bd398b 6191 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6192 unwsec = sec;
6193 }
6194
6195 if (!unwsec)
6196 printf (_("\nThere are no unwind sections in this file.\n"));
6197
6198 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6199 {
18bd398b 6200 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6201 {
57346661
AM		 6202 printf (_("\nUnwind section "));
6203 printf (_("'%s'"), SECTION_NAME (sec));
6204
6205 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6206 (unsigned long) sec->sh_offset,
89fac5e3 6207 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6208
6209 slurp_hppa_unwind_table (file, &aux, sec);
6210 if (aux.table_len > 0)
6211 dump_hppa_unwind (&aux);
6212
6213 if (aux.table)
6214 free ((char *) aux.table);
6215 aux.table = NULL;
6216 }
6217 }
6218
6219 if (aux.symtab)
6220 free (aux.symtab);
6221 if (aux.strtab)
6222 free ((char *) aux.strtab);
6223
6224 return 1;
6225}
6226
0b6ae522
DJ		 6227struct arm_section
6228{
6229 unsigned char *data;
6230
6231 Elf_Internal_Shdr *sec;
6232 Elf_Internal_Rela *rela;
6233 unsigned long nrelas;
6234 unsigned int rel_type;
6235
6236 Elf_Internal_Rela *next_rela;
6237};
6238
6239struct arm_unw_aux_info
6240{
6241 FILE *file;
6242
6243 Elf_Internal_Sym *symtab; /* The symbol table. */
6244 unsigned long nsyms; /* Number of symbols. */
6245 char *strtab; /* The string table. */
6246 unsigned long strtab_size; /* Size of string table. */
6247};
6248
6249static const char *
6250arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6251 bfd_vma fn, struct absaddr addr)
6252{
6253 const char *procname;
6254 bfd_vma sym_offset;
6255
6256 if (addr.section == SHN_UNDEF)
6257 addr.offset = fn;
6258
6259 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6260 aux->strtab_size, addr, &procname,
6261 &sym_offset);
6262
6263 print_vma (fn, PREFIX_HEX);
6264
6265 if (procname)
6266 {
6267 fputs (" <", stdout);
6268 fputs (procname, stdout);
6269
6270 if (sym_offset)
6271 printf ("+0x%lx", (unsigned long) sym_offset);
6272 fputc ('>', stdout);
6273 }
6274
6275 return procname;
6276}
6277
6278static void
6279arm_free_section (struct arm_section *arm_sec)
6280{
6281 if (arm_sec->data != NULL)
6282 free (arm_sec->data);
6283
6284 if (arm_sec->rela != NULL)
6285 free (arm_sec->rela);
6286}
6287
6288static int
6289arm_section_get_word (struct arm_unw_aux_info *aux,
6290 struct arm_section *arm_sec,
6291 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6292 unsigned int *wordp, struct absaddr *addr)
6293{
6294 Elf_Internal_Rela *rp;
6295 Elf_Internal_Sym *sym;
6296 const char * relname;
6297 unsigned int word;
6298 bfd_boolean wrapped;
6299
6300 addr->section = SHN_UNDEF;
6301 addr->offset = 0;
6302
6303 if (sec != arm_sec->sec)
6304 {
6305 Elf_Internal_Shdr *relsec;
6306
6307 arm_free_section (arm_sec);
6308
6309 arm_sec->sec = sec;
6310 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6311 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6312 arm_sec->rela = NULL;
6313 arm_sec->nrelas = 0;
6314
6315 for (relsec = section_headers;
6316 relsec < section_headers + elf_header.e_shnum;
6317 ++relsec)
6318 {
6319 if (relsec->sh_info >= elf_header.e_shnum
6320 || section_headers + relsec->sh_info != sec)
6321 continue;
6322
6323 if (relsec->sh_type == SHT_REL)
6324 {
6325 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6326 relsec->sh_size,
6327 & arm_sec->rela, & arm_sec->nrelas))
6328 return 0;
6329 break;
6330 }
6331 else if (relsec->sh_type == SHT_RELA)
6332 {
6333 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6334 relsec->sh_size,
6335 & arm_sec->rela, & arm_sec->nrelas))
6336 return 0;
6337 break;
6338 }
6339 }
6340
6341 arm_sec->next_rela = arm_sec->rela;
6342 }
6343
6344 if (arm_sec->data == NULL)
6345 return 0;
6346
6347 word = byte_get (arm_sec->data + word_offset, 4);
6348
6349 wrapped = FALSE;
6350 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6351 {
6352 bfd_vma prelval, offset;
6353
6354 if (rp->r_offset > word_offset && !wrapped)
6355 {
6356 rp = arm_sec->rela;
6357 wrapped = TRUE;
6358 }
6359 if (rp->r_offset > word_offset)
6360 break;
6361
6362 if (rp->r_offset & 3)
6363 {
6364 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6365 (unsigned long) rp->r_offset);
6366 continue;
6367 }
6368
6369 if (rp->r_offset < word_offset)
6370 continue;
6371
fa197c1c
PB		 6372 switch (elf_header.e_machine)
6373 {
6374 case EM_ARM:
6375 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6376 break;
6377
6378 case EM_TI_C6000:
6379 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6380 break;
6381
6382 default:
6383 abort();
6384 }
0b6ae522 6385
fa197c1c
PB		 6386 if (streq (relname, "R_ARM_NONE")
6387 || streq (relname, "R_C6000_NONE"))
0b6ae522
DJ		 6388 continue;
6389
fa197c1c
PB		 6390 if (!(streq (relname, "R_ARM_PREL31")
6391 || streq (relname, "R_C6000_PREL31")))
0b6ae522
DJ		 6392 {
6393 warn (_("Skipping unexpected relocation type %s\n"), relname);
6394 continue;
6395 }
6396
6397 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6398
6399 if (arm_sec->rel_type == SHT_REL)
6400 {
6401 offset = word & 0x7fffffff;
6402 if (offset & 0x40000000)
6403 offset |= ~ (bfd_vma) 0x7fffffff;
6404 }
6405 else
6406 offset = rp->r_addend;
6407
6408 offset += sym->st_value;
6409 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6410
fa197c1c
PB		 6411 if (streq (relname, "R_C6000_PREL31"))
6412 prelval >>= 1;
6413
0b6ae522
DJ		 6414 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6415 addr->section = sym->st_shndx;
6416 addr->offset = offset;
6417 break;
6418 }
6419
6420 *wordp = word;
6421 arm_sec->next_rela = rp;
6422
6423 return 1;
6424}
6425
fa197c1c
PB		 6426static const char *tic6x_unwind_regnames[16] = {
6427 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6428 "A14", "A13", "A12", "A11", "A10",
6429 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6430
0b6ae522 6431static void
fa197c1c 6432decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6433{
fa197c1c
PB		 6434 int i;
6435
6436 for (i = 12; mask; mask >>= 1, i--)
6437 {
6438 if (mask & 1)
6439 {
6440 fputs (tic6x_unwind_regnames[i], stdout);
6441 if (mask > 1)
6442 fputs (", ", stdout);
6443 }
6444 }
6445}
0b6ae522
DJ		 6446
6447#define ADVANCE \
6448 if (remaining == 0 && more_words) \
6449 { \
6450 data_offset += 4; \
6451 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6452 data_offset, &word, &addr)) \
6453 return; \
6454 remaining = 4; \
6455 more_words--; \
6456 } \
6457
6458#define GET_OP(OP) \
6459 ADVANCE; \
6460 if (remaining) \
6461 { \
6462 remaining--; \
6463 (OP) = word >> 24; \
6464 word <<= 8; \
6465 } \
6466 else \
6467 { \
2b692964 6468 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6469 return; \
6470 } \
cc5914eb 6471 printf ("0x%02x ", OP)
0b6ae522 6472
fa197c1c
PB		 6473static void
6474decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6475 unsigned int word, unsigned int remaining,
6476 unsigned int more_words,
6477 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6478 struct arm_section *data_arm_sec)
6479{
6480 struct absaddr addr;
0b6ae522
DJ		 6481
6482 /* Decode the unwinding instructions. */
6483 while (1)
6484 {
6485 unsigned int op, op2;
6486
6487 ADVANCE;
6488 if (remaining == 0)
6489 break;
6490 remaining--;
6491 op = word >> 24;
6492 word <<= 8;
6493
cc5914eb 6494 printf (" 0x%02x ", op);
0b6ae522
DJ		 6495
6496 if ((op & 0xc0) == 0x00)
6497 {
6498 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6499
cc5914eb 6500 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6501 }
6502 else if ((op & 0xc0) == 0x40)
6503 {
6504 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6505
cc5914eb 6506 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6507 }
6508 else if ((op & 0xf0) == 0x80)
6509 {
6510 GET_OP (op2);
6511 if (op == 0x80 && op2 == 0)
6512 printf (_("Refuse to unwind"));
6513 else
6514 {
6515 unsigned int mask = ((op & 0x0f) << 8) | op2;
6516 int first = 1;
6517 int i;
2b692964 6518
0b6ae522
DJ		 6519 printf ("pop {");
6520 for (i = 0; i < 12; i++)
6521 if (mask & (1 << i))
6522 {
6523 if (first)
6524 first = 0;
6525 else
6526 printf (", ");
6527 printf ("r%d", 4 + i);
6528 }
6529 printf ("}");
6530 }
6531 }
6532 else if ((op & 0xf0) == 0x90)
6533 {
6534 if (op == 0x9d || op == 0x9f)
6535 printf (_(" [Reserved]"));
6536 else
cc5914eb 6537 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6538 }
6539 else if ((op & 0xf0) == 0xa0)
6540 {
6541 int end = 4 + (op & 0x07);
6542 int first = 1;
6543 int i;
61865e30 6544
0b6ae522
DJ		 6545 printf (" pop {");
6546 for (i = 4; i <= end; i++)
6547 {
6548 if (first)
6549 first = 0;
6550 else
6551 printf (", ");
6552 printf ("r%d", i);
6553 }
6554 if (op & 0x08)
6555 {
6556 if (first)
6557 printf (", ");
6558 printf ("r14");
6559 }
6560 printf ("}");
6561 }
6562 else if (op == 0xb0)
6563 printf (_(" finish"));
6564 else if (op == 0xb1)
6565 {
6566 GET_OP (op2);
6567 if (op2 == 0 || (op2 & 0xf0) != 0)
6568 printf (_("[Spare]"));
6569 else
6570 {
6571 unsigned int mask = op2 & 0x0f;
6572 int first = 1;
6573 int i;
61865e30 6574
0b6ae522
DJ		 6575 printf ("pop {");
6576 for (i = 0; i < 12; i++)
6577 if (mask & (1 << i))
6578 {
6579 if (first)
6580 first = 0;
6581 else
6582 printf (", ");
6583 printf ("r%d", i);
6584 }
6585 printf ("}");
6586 }
6587 }
6588 else if (op == 0xb2)
6589 {
b115cf96 6590 unsigned char buf[9];
0b6ae522
DJ		 6591 unsigned int i, len;
6592 unsigned long offset;
61865e30 6593
b115cf96 6594 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6595 {
6596 GET_OP (buf[i]);
6597 if ((buf[i] & 0x80) == 0)
6598 break;
6599 }
6600 assert (i < sizeof (buf));
6601 offset = read_uleb128 (buf, &len);
6602 assert (len == i + 1);
6603 offset = offset * 4 + 0x204;
cc5914eb 6604 printf ("vsp = vsp + %ld", offset);
0b6ae522 6605 }
61865e30 6606 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6607 {
61865e30
NC		 6608 unsigned int first, last;
6609
6610 GET_OP (op2);
6611 first = op2 >> 4;
6612 last = op2 & 0x0f;
6613 if (op == 0xc8)
6614 first = first + 16;
6615 printf ("pop {D%d", first);
6616 if (last)
6617 printf ("-D%d", first + last);
6618 printf ("}");
6619 }
6620 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6621 {
6622 unsigned int count = op & 0x07;
6623
6624 printf ("pop {D8");
6625 if (count)
6626 printf ("-D%d", 8 + count);
6627 printf ("}");
6628 }
6629 else if (op >= 0xc0 && op <= 0xc5)
6630 {
6631 unsigned int count = op & 0x07;
6632
6633 printf (" pop {wR10");
6634 if (count)
6635 printf ("-wR%d", 10 + count);
6636 printf ("}");
6637 }
6638 else if (op == 0xc6)
6639 {
6640 unsigned int first, last;
6641
6642 GET_OP (op2);
6643 first = op2 >> 4;
6644 last = op2 & 0x0f;
6645 printf ("pop {wR%d", first);
6646 if (last)
6647 printf ("-wR%d", first + last);
6648 printf ("}");
6649 }
6650 else if (op == 0xc7)
6651 {
6652 GET_OP (op2);
6653 if (op2 == 0 || (op2 & 0xf0) != 0)
6654 printf (_("[Spare]"));
0b6ae522
DJ		 6655 else
6656 {
61865e30
NC		 6657 unsigned int mask = op2 & 0x0f;
6658 int first = 1;
6659 int i;
6660
6661 printf ("pop {");
6662 for (i = 0; i < 4; i++)
6663 if (mask & (1 << i))
6664 {
6665 if (first)
6666 first = 0;
6667 else
6668 printf (", ");
6669 printf ("wCGR%d", i);
6670 }
6671 printf ("}");
0b6ae522
DJ		 6672 }
6673 }
61865e30
NC		 6674 else
6675 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6676 printf ("\n");
6677 }
fa197c1c
PB		 6678}
6679
6680static void
6681decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6682 unsigned int word, unsigned int remaining,
6683 unsigned int more_words,
6684 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6685 struct arm_section *data_arm_sec)
6686{
6687 struct absaddr addr;
6688
6689 /* Decode the unwinding instructions. */
6690 while (1)
6691 {
6692 unsigned int op, op2;
6693
6694 ADVANCE;
6695 if (remaining == 0)
6696 break;
6697 remaining--;
6698 op = word >> 24;
6699 word <<= 8;
6700
6701 printf (_(" 0x%02x "), op);
6702
6703 if ((op & 0xc0) == 0x00)
6704 {
6705 int offset = ((op & 0x3f) << 3) + 8;
6706 printf (_(" sp = sp + %d"), offset);
6707 }
6708 else if ((op & 0xc0) == 0x80)
6709 {
6710 GET_OP (op2);
6711 if (op == 0x80 && op2 == 0)
6712 printf (_("Refuse to unwind"));
6713 else
6714 {
6715 unsigned int mask = ((op & 0x1f) << 8) | op2;
6716 if (op & 0x20)
6717 printf ("pop compact {");
6718 else
6719 printf ("pop {");
6720
6721 decode_tic6x_unwind_regmask (mask);
6722 printf("}");
6723 }
6724 }
6725 else if ((op & 0xf0) == 0xc0)
6726 {
6727 unsigned int reg;
6728 unsigned int nregs;
6729 unsigned int i;
6730 const char *name;
6731 struct {
6732 unsigned int offset;
6733 unsigned int reg;
6734 } regpos[16];
6735
6736 /* Scan entire instruction first so that GET_OP output is not
6737 interleaved with disassembly. */
6738 nregs = 0;
6739 for (i = 0; nregs < (op & 0xf); i++)
6740 {
6741 GET_OP (op2);
6742 reg = op2 >> 4;
6743 if (reg != 0xf)
6744 {
6745 regpos[nregs].offset = i * 2;
6746 regpos[nregs].reg = reg;
6747 nregs++;
6748 }
6749
6750 reg = op2 & 0xf;
6751 if (reg != 0xf)
6752 {
6753 regpos[nregs].offset = i * 2 + 1;
6754 regpos[nregs].reg = reg;
6755 nregs++;
6756 }
6757 }
6758
6759 printf (_("pop frame {"));
6760 reg = nregs - 1;
6761 for (i = i * 2; i > 0; i--)
6762 {
6763 if (regpos[reg].offset == i - 1)
6764 {
6765 name = tic6x_unwind_regnames[regpos[reg].reg];
6766 if (reg > 0)
6767 reg--;
6768 }
6769 else
6770 name = _("[pad]");
6771
6772 fputs (name, stdout);
6773 if (i > 1)
6774 printf (", ");
6775 }
6776
6777 printf ("}");
6778 }
6779 else if (op == 0xd0)
6780 printf (" MOV FP, SP");
6781 else if (op == 0xd1)
6782 printf (" __c6xabi_pop_rts");
6783 else if (op == 0xd2)
6784 {
6785 unsigned char buf[9];
6786 unsigned int i, len;
6787 unsigned long offset;
6788 for (i = 0; i < sizeof (buf); i++)
6789 {
6790 GET_OP (buf[i]);
6791 if ((buf[i] & 0x80) == 0)
6792 break;
6793 }
6794 assert (i < sizeof (buf));
6795 offset = read_uleb128 (buf, &len);
6796 assert (len == i + 1);
6797 offset = offset * 8 + 0x408;
6798 printf (_("sp = sp + %ld"), offset);
6799 }
6800 else if ((op & 0xf0) == 0xe0)
6801 {
6802 if ((op & 0x0f) == 7)
6803 printf (" RETURN");
6804 else
6805 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6806 }
6807 else
6808 {
6809 printf (_(" [unsupported opcode]"));
6810 }
6811 putchar ('\n');
6812 }
6813}
6814
6815static bfd_vma
6816expand_prel31 (bfd_vma word, bfd_vma where)
6817{
6818 bfd_vma offset;
6819
6820 offset = word & 0x7fffffff;
6821 if (offset & 0x40000000)
6822 offset |= ~ (bfd_vma) 0x7fffffff;
6823
6824 if (elf_header.e_machine == EM_TI_C6000)
6825 offset <<= 1;
6826
6827 return offset + where;
6828}
6829
6830static void
6831decode_arm_unwind (struct arm_unw_aux_info *aux,
6832 unsigned int word, unsigned int remaining,
6833 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6834 struct arm_section *data_arm_sec)
6835{
6836 int per_index;
6837 unsigned int more_words = 0;
6838 struct absaddr addr;
6839
6840 if (remaining == 0)
6841 {
6842 /* Fetch the first word. */
6843 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6844 &word, &addr))
6845 return;
6846 remaining = 4;
6847 }
6848
6849 if ((word & 0x80000000) == 0)
6850 {
6851 /* Expand prel31 for personality routine. */
6852 bfd_vma fn;
6853 const char *procname;
6854
6855 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6856 printf (_(" Personality routine: "));
6857 procname = arm_print_vma_and_name (aux, fn, addr);
6858 fputc ('\n', stdout);
6859
6860 /* The GCC personality routines use the standard compact
6861 encoding, starting with one byte giving the number of
6862 words. */
6863 if (procname != NULL
6864 && (const_strneq (procname, "__gcc_personality_v0")
6865 || const_strneq (procname, "__gxx_personality_v0")
6866 || const_strneq (procname, "__gcj_personality_v0")
6867 || const_strneq (procname, "__gnu_objc_personality_v0")))
6868 {
6869 remaining = 0;
6870 more_words = 1;
6871 ADVANCE;
6872 if (!remaining)
6873 {
6874 printf (_(" [Truncated data]\n"));
6875 return;
6876 }
6877 more_words = word >> 24;
6878 word <<= 8;
6879 remaining--;
6880 per_index = -1;
6881 }
6882 else
6883 return;
6884 }
6885 else
6886 {
6887
6888 per_index = (word >> 24) & 0x7f;
6889 printf (_(" Compact model %d\n"), per_index);
6890 if (per_index == 0)
6891 {
6892 more_words = 0;
6893 word <<= 8;
6894 remaining--;
6895 }
6896 else if (per_index < 3)
6897 {
6898 more_words = (word >> 16) & 0xff;
6899 word <<= 16;
6900 remaining -= 2;
6901 }
6902 }
6903
6904 switch (elf_header.e_machine)
6905 {
6906 case EM_ARM:
6907 if (per_index < 3)
6908 {
6909 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6910 data_offset, data_sec, data_arm_sec);
6911 }
6912 else
6913 printf (" [reserved]\n");
6914 break;
6915
6916 case EM_TI_C6000:
6917 if (per_index < 3)
6918 {
6919 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6920 data_offset, data_sec, data_arm_sec);
6921 }
6922 else if (per_index < 5)
6923 {
6924 if (((word >> 17) & 0x7f) == 0x7f)
6925 printf (_(" Restore stack from frame pointer\n"));
6926 else
6927 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6928 printf (_(" Registers restored: "));
6929 if (per_index == 4)
6930 printf (" (compact) ");
6931 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6932 putchar ('\n');
6933 printf (_(" Return register: %s\n"),
6934 tic6x_unwind_regnames[word & 0xf]);
6935 }
6936 else
6937 printf (" [reserved]\n");
6938 break;
6939
6940 default:
6941 abort ();
6942 }
0b6ae522
DJ		 6943
6944 /* Decode the descriptors. Not implemented. */
6945}
6946
6947static void
6948dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6949{
6950 struct arm_section exidx_arm_sec, extab_arm_sec;
6951 unsigned int i, exidx_len;
6952
6953 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6954 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6955 exidx_len = exidx_sec->sh_size / 8;
6956
6957 for (i = 0; i < exidx_len; i++)
6958 {
6959 unsigned int exidx_fn, exidx_entry;
6960 struct absaddr fn_addr, entry_addr;
6961 bfd_vma fn;
6962
6963 fputc ('\n', stdout);
6964
6965 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6966 8 * i, &exidx_fn, &fn_addr)
6967 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6968 8 * i + 4, &exidx_entry, &entry_addr))
6969 {
6970 arm_free_section (&exidx_arm_sec);
6971 arm_free_section (&extab_arm_sec);
6972 return;
6973 }
6974
fa197c1c 6975 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522
DJ		 6976
6977 arm_print_vma_and_name (aux, fn, entry_addr);
6978 fputs (": ", stdout);
6979
6980 if (exidx_entry == 1)
6981 {
6982 print_vma (exidx_entry, PREFIX_HEX);
6983 fputs (" [cantunwind]\n", stdout);
6984 }
6985 else if (exidx_entry & 0x80000000)
6986 {
6987 print_vma (exidx_entry, PREFIX_HEX);
6988 fputc ('\n', stdout);
6989 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6990 }
6991 else
6992 {
8f73510c 6993 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 6994 Elf_Internal_Shdr *table_sec;
6995
6996 fputs ("@", stdout);
fa197c1c 6997 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 6998 print_vma (table, PREFIX_HEX);
6999 printf ("\n");
7000
7001 /* Locate the matching .ARM.extab. */
7002 if (entry_addr.section != SHN_UNDEF
7003 && entry_addr.section < elf_header.e_shnum)
7004 {
7005 table_sec = section_headers + entry_addr.section;
7006 table_offset = entry_addr.offset;
7007 }
7008 else
7009 {
7010 table_sec = find_section_by_address (table);
7011 if (table_sec != NULL)
7012 table_offset = table - table_sec->sh_addr;
7013 }
7014 if (table_sec == NULL)
7015 {
7016 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7017 (unsigned long) table);
7018 continue;
7019 }
7020 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7021 &extab_arm_sec);
7022 }
7023 }
7024
7025 printf ("\n");
7026
7027 arm_free_section (&exidx_arm_sec);
7028 arm_free_section (&extab_arm_sec);
7029}
7030
fa197c1c 7031/* Used for both ARM and C6X unwinding tables. */
0b6ae522
DJ		 7032static int
7033arm_process_unwind (FILE *file)
7034{
7035 struct arm_unw_aux_info aux;
7036 Elf_Internal_Shdr *unwsec = NULL;
7037 Elf_Internal_Shdr *strsec;
7038 Elf_Internal_Shdr *sec;
7039 unsigned long i;
fa197c1c 7040 unsigned int sec_type;
0b6ae522
DJ		 7041
7042 memset (& aux, 0, sizeof (aux));
7043 aux.file = file;
7044
fa197c1c
PB		 7045 switch (elf_header.e_machine)
7046 {
7047 case EM_ARM:
7048 sec_type = SHT_ARM_EXIDX;
7049 break;
7050
7051 case EM_TI_C6000:
7052 sec_type = SHT_C6000_UNWIND;
7053 break;
7054
7055 default:
7056 abort();
7057 }
7058
0b6ae522
DJ		 7059 if (string_table == NULL)
7060 return 1;
7061
7062 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7063 {
7064 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7065 {
7066 aux.nsyms = sec->sh_size / sec->sh_entsize;
7067 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7068
7069 strsec = section_headers + sec->sh_link;
59245841 7070 assert (aux.strtab == NULL);
0b6ae522
DJ		 7071 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7072 1, strsec->sh_size, _("string table"));
7073 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7074 }
fa197c1c 7075 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7076 unwsec = sec;
7077 }
7078
7079 if (!unwsec)
7080 printf (_("\nThere are no unwind sections in this file.\n"));
7081
7082 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7083 {
fa197c1c 7084 if (sec->sh_type == sec_type)
0b6ae522
DJ		 7085 {
7086 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7087 SECTION_NAME (sec),
7088 (unsigned long) sec->sh_offset,
7089 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7090
7091 dump_arm_unwind (&aux, sec);
7092 }
7093 }
7094
7095 if (aux.symtab)
7096 free (aux.symtab);
7097 if (aux.strtab)
7098 free ((char *) aux.strtab);
7099
7100 return 1;
7101}
7102
57346661 7103static int
2cf0635d 7104process_unwind (FILE * file)
57346661 7105{
2cf0635d
NC		 7106 struct unwind_handler
7107 {
57346661 7108 int machtype;
2cf0635d
NC		 7109 int (* handler)(FILE *);
7110 } handlers[] =
7111 {
0b6ae522 7112 { EM_ARM, arm_process_unwind },
57346661
AM		 7113 { EM_IA_64, ia64_process_unwind },
7114 { EM_PARISC, hppa_process_unwind },
fa197c1c 7115 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7116 { 0, 0 }
7117 };
7118 int i;
7119
7120 if (!do_unwind)
7121 return 1;
7122
7123 for (i = 0; handlers[i].handler != NULL; i++)
7124 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7125 return handlers[i].handler (file);
57346661
AM		 7126
7127 printf (_("\nThere are no unwind sections in this file.\n"));
7128 return 1;
7129}
7130
252b5132 7131static void
2cf0635d 7132dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7133{
7134 switch (entry->d_tag)
7135 {
7136 case DT_MIPS_FLAGS:
7137 if (entry->d_un.d_val == 0)
2b692964 7138 printf (_("NONE\n"));
252b5132
RH		 7139 else
7140 {
7141 static const char * opts[] =
7142 {
7143 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7144 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7145 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7146 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7147 "RLD_ORDER_SAFE"
7148 };
7149 unsigned int cnt;
7150 int first = 1;
2b692964 7151
60bca95a 7152 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7153 if (entry->d_un.d_val & (1 << cnt))
7154 {
7155 printf ("%s%s", first ? "" : " ", opts[cnt]);
7156 first = 0;
7157 }
7158 puts ("");
7159 }
7160 break;
103f02d3 7161
252b5132 7162 case DT_MIPS_IVERSION:
d79b3d50 7163 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
2b692964 7164 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7165 else
2b692964 7166 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
252b5132 7167 break;
103f02d3 7168
252b5132
RH		 7169 case DT_MIPS_TIME_STAMP:
7170 {
7171 char timebuf[20];
2cf0635d 7172 struct tm * tmp;
50da7a9c 7173
91d6fa6a
NC		 7174 time_t atime = entry->d_un.d_val;
7175 tmp = gmtime (&atime);
e9e44622
JJ		 7176 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7177 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7178 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2b692964 7179 printf (_("Time Stamp: %s\n"), timebuf);
252b5132
RH		 7180 }
7181 break;
103f02d3 7182
252b5132
RH		 7183 case DT_MIPS_RLD_VERSION:
7184 case DT_MIPS_LOCAL_GOTNO:
7185 case DT_MIPS_CONFLICTNO:
7186 case DT_MIPS_LIBLISTNO:
7187 case DT_MIPS_SYMTABNO:
7188 case DT_MIPS_UNREFEXTNO:
7189 case DT_MIPS_HIPAGENO:
7190 case DT_MIPS_DELTA_CLASS_NO:
7191 case DT_MIPS_DELTA_INSTANCE_NO:
7192 case DT_MIPS_DELTA_RELOC_NO:
7193 case DT_MIPS_DELTA_SYM_NO:
7194 case DT_MIPS_DELTA_CLASSSYM_NO:
7195 case DT_MIPS_COMPACT_SIZE:
7196 printf ("%ld\n", (long) entry->d_un.d_ptr);
7197 break;
103f02d3
UD		 7198
7199 default:
0af1713e 7200 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
103f02d3
UD		 7201 }
7202}
7203
103f02d3 7204static void
2cf0635d 7205dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7206{
7207 switch (entry->d_tag)
7208 {
7209 case DT_HP_DLD_FLAGS:
7210 {
7211 static struct
7212 {
7213 long int bit;
2cf0635d 7214 const char * str;
5e220199
NC		 7215 }
7216 flags[] =
7217 {
7218 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7219 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7220 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7221 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7222 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7223 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7224 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7225 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7226 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7227 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7228 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7229 { DT_HP_GST, "HP_GST" },
7230 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7231 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7232 { DT_HP_NODELETE, "HP_NODELETE" },
7233 { DT_HP_GROUP, "HP_GROUP" },
7234 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7235 };
103f02d3 7236 int first = 1;
5e220199 7237 size_t cnt;
f7a99963 7238 bfd_vma val = entry->d_un.d_val;
103f02d3 7239
60bca95a 7240 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7241 if (val & flags[cnt].bit)
30800947
NC		 7242 {
7243 if (! first)
7244 putchar (' ');
7245 fputs (flags[cnt].str, stdout);
7246 first = 0;
7247 val ^= flags[cnt].bit;
7248 }
76da6bbe 7249
103f02d3 7250 if (val != 0 || first)
f7a99963
NC		 7251 {
7252 if (! first)
7253 putchar (' ');
7254 print_vma (val, HEX);
7255 }
103f02d3
UD		 7256 }
7257 break;
76da6bbe 7258
252b5132 7259 default:
f7a99963
NC		 7260 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7261 break;
252b5132 7262 }
35b1837e 7263 putchar ('\n');
252b5132
RH		 7264}
7265
28f997cf
TG		 7266#ifdef BFD64
7267
7268/* VMS vs Unix time offset and factor. */
7269
7270#define VMS_EPOCH_OFFSET 35067168000000000LL
7271#define VMS_GRANULARITY_FACTOR 10000000
7272
7273/* Display a VMS time in a human readable format. */
7274
7275static void
7276print_vms_time (bfd_int64_t vmstime)
7277{
7278 struct tm *tm;
7279 time_t unxtime;
7280
7281 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7282 tm = gmtime (&unxtime);
7283 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7284 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7285 tm->tm_hour, tm->tm_min, tm->tm_sec);
7286}
7287#endif /* BFD64 */
7288
ecc51f48 7289static void
2cf0635d 7290dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7291{
7292 switch (entry->d_tag)
7293 {
0de14b54 7294 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7295 /* First 3 slots reserved. */
ecc51f48
NC		 7296 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7297 printf (" -- ");
7298 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7299 break;
7300
28f997cf
TG		 7301 case DT_IA_64_VMS_LINKTIME:
7302#ifdef BFD64
7303 print_vms_time (entry->d_un.d_val);
7304#endif
7305 break;
7306
7307 case DT_IA_64_VMS_LNKFLAGS:
7308 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7309 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7310 printf (" CALL_DEBUG");
7311 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7312 printf (" NOP0BUFS");
7313 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7314 printf (" P0IMAGE");
7315 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7316 printf (" MKTHREADS");
7317 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7318 printf (" UPCALLS");
7319 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7320 printf (" IMGSTA");
7321 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7322 printf (" INITIALIZE");
7323 if (entry->d_un.d_val & VMS_LF_MAIN)
7324 printf (" MAIN");
7325 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7326 printf (" EXE_INIT");
7327 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7328 printf (" TBK_IN_IMG");
7329 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7330 printf (" DBG_IN_IMG");
7331 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7332 printf (" TBK_IN_DSF");
7333 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7334 printf (" DBG_IN_DSF");
7335 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7336 printf (" SIGNATURES");
7337 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7338 printf (" REL_SEG_OFF");
7339 break;
7340
bdf4d63a
JJ		 7341 default:
7342 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7343 break;
ecc51f48 7344 }
bdf4d63a 7345 putchar ('\n');
ecc51f48
NC		 7346}
7347
252b5132 7348static int
2cf0635d 7349get_32bit_dynamic_section (FILE * file)
252b5132 7350{
2cf0635d
NC		 7351 Elf32_External_Dyn * edyn;
7352 Elf32_External_Dyn * ext;
7353 Elf_Internal_Dyn * entry;
103f02d3 7354
3f5e193b
NC		 7355 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7356 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7357 if (!edyn)
7358 return 0;
103f02d3 7359
ba2685cc
AM		 7360/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7361 might not have the luxury of section headers. Look for the DT_NULL
7362 terminator to determine the number of entries. */
7363 for (ext = edyn, dynamic_nent = 0;
7364 (char *) ext < (char *) edyn + dynamic_size;
7365 ext++)
7366 {
7367 dynamic_nent++;
7368 if (BYTE_GET (ext->d_tag) == DT_NULL)
7369 break;
7370 }
252b5132 7371
3f5e193b
NC		 7372 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7373 sizeof (* entry));
b2d38a17 7374 if (dynamic_section == NULL)
252b5132 7375 {
9ea033b2
NC		 7376 error (_("Out of memory\n"));
7377 free (edyn);
7378 return 0;
7379 }
252b5132 7380
fb514b26 7381 for (ext = edyn, entry = dynamic_section;
ba2685cc 7382 entry < dynamic_section + dynamic_nent;
fb514b26 7383 ext++, entry++)
9ea033b2 7384 {
fb514b26
AM		 7385 entry->d_tag = BYTE_GET (ext->d_tag);
7386 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7387 }
7388
9ea033b2
NC		 7389 free (edyn);
7390
7391 return 1;
7392}
7393
7394static int
2cf0635d 7395get_64bit_dynamic_section (FILE * file)
9ea033b2 7396{
2cf0635d
NC		 7397 Elf64_External_Dyn * edyn;
7398 Elf64_External_Dyn * ext;
7399 Elf_Internal_Dyn * entry;
103f02d3 7400
3f5e193b
NC		 7401 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7402 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7403 if (!edyn)
7404 return 0;
103f02d3 7405
ba2685cc
AM		 7406/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7407 might not have the luxury of section headers. Look for the DT_NULL
7408 terminator to determine the number of entries. */
7409 for (ext = edyn, dynamic_nent = 0;
7410 (char *) ext < (char *) edyn + dynamic_size;
7411 ext++)
7412 {
7413 dynamic_nent++;
66543521 7414 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7415 break;
7416 }
252b5132 7417
3f5e193b
NC		 7418 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7419 sizeof (* entry));
b2d38a17 7420 if (dynamic_section == NULL)
252b5132
RH		 7421 {
7422 error (_("Out of memory\n"));
7423 free (edyn);
7424 return 0;
7425 }
7426
fb514b26 7427 for (ext = edyn, entry = dynamic_section;
ba2685cc 7428 entry < dynamic_section + dynamic_nent;
fb514b26 7429 ext++, entry++)
252b5132 7430 {
66543521
AM		 7431 entry->d_tag = BYTE_GET (ext->d_tag);
7432 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7433 }
7434
7435 free (edyn);
7436
9ea033b2
NC		 7437 return 1;
7438}
7439
e9e44622
JJ		 7440static void
7441print_dynamic_flags (bfd_vma flags)
d1133906 7442{
e9e44622 7443 int first = 1;
13ae64f3 7444
d1133906
NC		 7445 while (flags)
7446 {
7447 bfd_vma flag;
7448
7449 flag = flags & - flags;
7450 flags &= ~ flag;
7451
e9e44622
JJ		 7452 if (first)
7453 first = 0;
7454 else
7455 putc (' ', stdout);
13ae64f3 7456
d1133906
NC		 7457 switch (flag)
7458 {
e9e44622
JJ		 7459 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7460 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7461 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7462 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7463 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7464 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7465 }
7466 }
e9e44622 7467 puts ("");
d1133906
NC		 7468}
7469
b2d38a17
NC		 7470/* Parse and display the contents of the dynamic section. */
7471
9ea033b2 7472static int
2cf0635d 7473process_dynamic_section (FILE * file)
9ea033b2 7474{
2cf0635d 7475 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7476
7477 if (dynamic_size == 0)
7478 {
7479 if (do_dynamic)
b2d38a17 7480 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7481
7482 return 1;
7483 }
7484
7485 if (is_32bit_elf)
7486 {
b2d38a17 7487 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7488 return 0;
7489 }
b2d38a17 7490 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7491 return 0;
7492
252b5132
RH		 7493 /* Find the appropriate symbol table. */
7494 if (dynamic_symbols == NULL)
7495 {
86dba8ee
AM		 7496 for (entry = dynamic_section;
7497 entry < dynamic_section + dynamic_nent;
7498 ++entry)
252b5132 7499 {
c8286bd1 7500 Elf_Internal_Shdr section;
252b5132
RH		 7501
7502 if (entry->d_tag != DT_SYMTAB)
7503 continue;
7504
7505 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7506
7507 /* Since we do not know how big the symbol table is,
7508 we default to reading in the entire file (!) and
7509 processing that. This is overkill, I know, but it
e3c8793a 7510 should work. */
d93f0186 7511 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7512
fb52b2f4
NC		 7513 if (archive_file_offset != 0)
7514 section.sh_size = archive_file_size - section.sh_offset;
7515 else
7516 {
7517 if (fseek (file, 0, SEEK_END))
591a748a 7518 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7519
7520 section.sh_size = ftell (file) - section.sh_offset;
7521 }
252b5132 7522
9ea033b2 7523 if (is_32bit_elf)
9ad5cbcf 7524 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7525 else
9ad5cbcf 7526 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7527
9ad5cbcf 7528 num_dynamic_syms = section.sh_size / section.sh_entsize;
19936277 7529 if (num_dynamic_syms < 1)
252b5132
RH		 7530 {
7531 error (_("Unable to determine the number of symbols to load\n"));
7532 continue;
7533 }
7534
9ad5cbcf 7535 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
252b5132
RH		 7536 }
7537 }
7538
7539 /* Similarly find a string table. */
7540 if (dynamic_strings == NULL)
7541 {
86dba8ee
AM		 7542 for (entry = dynamic_section;
7543 entry < dynamic_section + dynamic_nent;
7544 ++entry)
252b5132
RH		 7545 {
7546 unsigned long offset;
b34976b6 7547 long str_tab_len;
252b5132
RH		 7548
7549 if (entry->d_tag != DT_STRTAB)
7550 continue;
7551
7552 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7553
7554 /* Since we do not know how big the string table is,
7555 we default to reading in the entire file (!) and
7556 processing that. This is overkill, I know, but it
e3c8793a 7557 should work. */
252b5132 7558
d93f0186 7559 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7560
7561 if (archive_file_offset != 0)
7562 str_tab_len = archive_file_size - offset;
7563 else
7564 {
7565 if (fseek (file, 0, SEEK_END))
7566 error (_("Unable to seek to end of file\n"));
7567 str_tab_len = ftell (file) - offset;
7568 }
252b5132
RH		 7569
7570 if (str_tab_len < 1)
7571 {
7572 error
7573 (_("Unable to determine the length of the dynamic string table\n"));
7574 continue;
7575 }
7576
3f5e193b
NC		 7577 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7578 str_tab_len,
7579 _("dynamic string table"));
59245841 7580 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7581 break;
7582 }
7583 }
7584
7585 /* And find the syminfo section if available. */
7586 if (dynamic_syminfo == NULL)
7587 {
3e8bba36 7588 unsigned long syminsz = 0;
252b5132 7589
86dba8ee
AM		 7590 for (entry = dynamic_section;
7591 entry < dynamic_section + dynamic_nent;
7592 ++entry)
252b5132
RH		 7593 {
7594 if (entry->d_tag == DT_SYMINENT)
7595 {
7596 /* Note: these braces are necessary to avoid a syntax
7597 error from the SunOS4 C compiler. */
7598 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7599 }
7600 else if (entry->d_tag == DT_SYMINSZ)
7601 syminsz = entry->d_un.d_val;
7602 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7603 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7604 syminsz);
252b5132
RH		 7605 }
7606
7607 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7608 {
2cf0635d
NC		 7609 Elf_External_Syminfo * extsyminfo;
7610 Elf_External_Syminfo * extsym;
7611 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7612
7613 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7614 extsyminfo = (Elf_External_Syminfo *)
7615 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7616 _("symbol information"));
a6e9f9df
AM		 7617 if (!extsyminfo)
7618 return 0;
252b5132 7619
3f5e193b 7620 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7621 if (dynamic_syminfo == NULL)
7622 {
7623 error (_("Out of memory\n"));
7624 return 0;
7625 }
7626
7627 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7628 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7629 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7630 ++syminfo, ++extsym)
252b5132 7631 {
86dba8ee
AM		 7632 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7633 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7634 }
7635
7636 free (extsyminfo);
7637 }
7638 }
7639
7640 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7641 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7642 dynamic_addr, dynamic_nent);
252b5132
RH		 7643 if (do_dynamic)
7644 printf (_(" Tag Type Name/Value\n"));
7645
86dba8ee
AM		 7646 for (entry = dynamic_section;
7647 entry < dynamic_section + dynamic_nent;
7648 entry++)
252b5132
RH		 7649 {
7650 if (do_dynamic)
f7a99963 7651 {
2cf0635d 7652 const char * dtype;
e699b9ff 7653
f7a99963
NC		 7654 putchar (' ');
7655 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7656 dtype = get_dynamic_type (entry->d_tag);
7657 printf (" (%s)%*s", dtype,
7658 ((is_32bit_elf ? 27 : 19)
7659 - (int) strlen (dtype)),
f7a99963
NC		 7660 " ");
7661 }
252b5132
RH		 7662
7663 switch (entry->d_tag)
7664 {
d1133906
NC		 7665 case DT_FLAGS:
7666 if (do_dynamic)
e9e44622 7667 print_dynamic_flags (entry->d_un.d_val);
d1133906 7668 break;
76da6bbe 7669
252b5132
RH		 7670 case DT_AUXILIARY:
7671 case DT_FILTER:
019148e4
L		 7672 case DT_CONFIG:
7673 case DT_DEPAUDIT:
7674 case DT_AUDIT:
252b5132
RH		 7675 if (do_dynamic)
7676 {
019148e4 7677 switch (entry->d_tag)
b34976b6 7678 {
019148e4
L		 7679 case DT_AUXILIARY:
7680 printf (_("Auxiliary library"));
7681 break;
7682
7683 case DT_FILTER:
7684 printf (_("Filter library"));
7685 break;
7686
b34976b6 7687 case DT_CONFIG:
019148e4
L		 7688 printf (_("Configuration file"));
7689 break;
7690
7691 case DT_DEPAUDIT:
7692 printf (_("Dependency audit library"));
7693 break;
7694
7695 case DT_AUDIT:
7696 printf (_("Audit library"));
7697 break;
7698 }
252b5132 7699
d79b3d50
NC		 7700 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7701 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7702 else
f7a99963
NC		 7703 {
7704 printf (": ");
7705 print_vma (entry->d_un.d_val, PREFIX_HEX);
7706 putchar ('\n');
7707 }
252b5132
RH		 7708 }
7709 break;
7710
dcefbbbd 7711 case DT_FEATURE:
252b5132
RH		 7712 if (do_dynamic)
7713 {
7714 printf (_("Flags:"));
86f55779 7715
252b5132
RH		 7716 if (entry->d_un.d_val == 0)
7717 printf (_(" None\n"));
7718 else
7719 {
7720 unsigned long int val = entry->d_un.d_val;
86f55779 7721
252b5132
RH		 7722 if (val & DTF_1_PARINIT)
7723 {
7724 printf (" PARINIT");
7725 val ^= DTF_1_PARINIT;
7726 }
dcefbbbd
L		 7727 if (val & DTF_1_CONFEXP)
7728 {
7729 printf (" CONFEXP");
7730 val ^= DTF_1_CONFEXP;
7731 }
252b5132
RH		 7732 if (val != 0)
7733 printf (" %lx", val);
7734 puts ("");
7735 }
7736 }
7737 break;
7738
7739 case DT_POSFLAG_1:
7740 if (do_dynamic)
7741 {
7742 printf (_("Flags:"));
86f55779 7743
252b5132
RH		 7744 if (entry->d_un.d_val == 0)
7745 printf (_(" None\n"));
7746 else
7747 {
7748 unsigned long int val = entry->d_un.d_val;
86f55779 7749
252b5132
RH		 7750 if (val & DF_P1_LAZYLOAD)
7751 {
7752 printf (" LAZYLOAD");
7753 val ^= DF_P1_LAZYLOAD;
7754 }
7755 if (val & DF_P1_GROUPPERM)
7756 {
7757 printf (" GROUPPERM");
7758 val ^= DF_P1_GROUPPERM;
7759 }
7760 if (val != 0)
7761 printf (" %lx", val);
7762 puts ("");
7763 }
7764 }
7765 break;
7766
7767 case DT_FLAGS_1:
7768 if (do_dynamic)
7769 {
7770 printf (_("Flags:"));
7771 if (entry->d_un.d_val == 0)
7772 printf (_(" None\n"));
7773 else
7774 {
7775 unsigned long int val = entry->d_un.d_val;
86f55779 7776
252b5132
RH		 7777 if (val & DF_1_NOW)
7778 {
7779 printf (" NOW");
7780 val ^= DF_1_NOW;
7781 }
7782 if (val & DF_1_GLOBAL)
7783 {
7784 printf (" GLOBAL");
7785 val ^= DF_1_GLOBAL;
7786 }
7787 if (val & DF_1_GROUP)
7788 {
7789 printf (" GROUP");
7790 val ^= DF_1_GROUP;
7791 }
7792 if (val & DF_1_NODELETE)
7793 {
7794 printf (" NODELETE");
7795 val ^= DF_1_NODELETE;
7796 }
7797 if (val & DF_1_LOADFLTR)
7798 {
7799 printf (" LOADFLTR");
7800 val ^= DF_1_LOADFLTR;
7801 }
7802 if (val & DF_1_INITFIRST)
7803 {
7804 printf (" INITFIRST");
7805 val ^= DF_1_INITFIRST;
7806 }
7807 if (val & DF_1_NOOPEN)
7808 {
7809 printf (" NOOPEN");
7810 val ^= DF_1_NOOPEN;
7811 }
7812 if (val & DF_1_ORIGIN)
7813 {
7814 printf (" ORIGIN");
7815 val ^= DF_1_ORIGIN;
7816 }
7817 if (val & DF_1_DIRECT)
7818 {
7819 printf (" DIRECT");
7820 val ^= DF_1_DIRECT;
7821 }
7822 if (val & DF_1_TRANS)
7823 {
7824 printf (" TRANS");
7825 val ^= DF_1_TRANS;
7826 }
7827 if (val & DF_1_INTERPOSE)
7828 {
7829 printf (" INTERPOSE");
7830 val ^= DF_1_INTERPOSE;
7831 }
f7db6139 7832 if (val & DF_1_NODEFLIB)
dcefbbbd 7833 {
f7db6139
L		 7834 printf (" NODEFLIB");
7835 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7836 }
7837 if (val & DF_1_NODUMP)
7838 {
7839 printf (" NODUMP");
7840 val ^= DF_1_NODUMP;
7841 }
7842 if (val & DF_1_CONLFAT)
7843 {
7844 printf (" CONLFAT");
7845 val ^= DF_1_CONLFAT;
7846 }
252b5132
RH		 7847 if (val != 0)
7848 printf (" %lx", val);
7849 puts ("");
7850 }
7851 }
7852 break;
7853
7854 case DT_PLTREL:
566b0d53 7855 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7856 if (do_dynamic)
7857 puts (get_dynamic_type (entry->d_un.d_val));
7858 break;
7859
7860 case DT_NULL :
7861 case DT_NEEDED :
7862 case DT_PLTGOT :
7863 case DT_HASH :
7864 case DT_STRTAB :
7865 case DT_SYMTAB :
7866 case DT_RELA :
7867 case DT_INIT :
7868 case DT_FINI :
7869 case DT_SONAME :
7870 case DT_RPATH :
7871 case DT_SYMBOLIC:
7872 case DT_REL :
7873 case DT_DEBUG :
7874 case DT_TEXTREL :
7875 case DT_JMPREL :
019148e4 7876 case DT_RUNPATH :
252b5132
RH		 7877 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7878
7879 if (do_dynamic)
7880 {
2cf0635d 7881 char * name;
252b5132 7882
d79b3d50
NC		 7883 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7884 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7885 else
d79b3d50 7886 name = NULL;
252b5132
RH		 7887
7888 if (name)
7889 {
7890 switch (entry->d_tag)
7891 {
7892 case DT_NEEDED:
7893 printf (_("Shared library: [%s]"), name);
7894
18bd398b 7895 if (streq (name, program_interpreter))
f7a99963 7896 printf (_(" program interpreter"));
252b5132
RH		 7897 break;
7898
7899 case DT_SONAME:
f7a99963 7900 printf (_("Library soname: [%s]"), name);
252b5132
RH		 7901 break;
7902
7903 case DT_RPATH:
f7a99963 7904 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 7905 break;
7906
019148e4
L		 7907 case DT_RUNPATH:
7908 printf (_("Library runpath: [%s]"), name);
7909 break;
7910
252b5132 7911 default:
f7a99963
NC		 7912 print_vma (entry->d_un.d_val, PREFIX_HEX);
7913 break;
252b5132
RH		 7914 }
7915 }
7916 else
f7a99963
NC		 7917 print_vma (entry->d_un.d_val, PREFIX_HEX);
7918
7919 putchar ('\n');
252b5132
RH		 7920 }
7921 break;
7922
7923 case DT_PLTRELSZ:
7924 case DT_RELASZ :
7925 case DT_STRSZ :
7926 case DT_RELSZ :
7927 case DT_RELAENT :
7928 case DT_SYMENT :
7929 case DT_RELENT :
566b0d53 7930 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 7931 case DT_PLTPADSZ:
7932 case DT_MOVEENT :
7933 case DT_MOVESZ :
7934 case DT_INIT_ARRAYSZ:
7935 case DT_FINI_ARRAYSZ:
047b2264
JJ		 7936 case DT_GNU_CONFLICTSZ:
7937 case DT_GNU_LIBLISTSZ:
252b5132 7938 if (do_dynamic)
f7a99963
NC		 7939 {
7940 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 7941 printf (_(" (bytes)\n"));
f7a99963 7942 }
252b5132
RH		 7943 break;
7944
7945 case DT_VERDEFNUM:
7946 case DT_VERNEEDNUM:
7947 case DT_RELACOUNT:
7948 case DT_RELCOUNT:
7949 if (do_dynamic)
f7a99963
NC		 7950 {
7951 print_vma (entry->d_un.d_val, UNSIGNED);
7952 putchar ('\n');
7953 }
252b5132
RH		 7954 break;
7955
7956 case DT_SYMINSZ:
7957 case DT_SYMINENT:
7958 case DT_SYMINFO:
7959 case DT_USED:
7960 case DT_INIT_ARRAY:
7961 case DT_FINI_ARRAY:
7962 if (do_dynamic)
7963 {
d79b3d50
NC		 7964 if (entry->d_tag == DT_USED
7965 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 7966 {
2cf0635d 7967 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 7968
b34976b6 7969 if (*name)
252b5132
RH		 7970 {
7971 printf (_("Not needed object: [%s]\n"), name);
7972 break;
7973 }
7974 }
103f02d3 7975
f7a99963
NC		 7976 print_vma (entry->d_un.d_val, PREFIX_HEX);
7977 putchar ('\n');
252b5132
RH		 7978 }
7979 break;
7980
7981 case DT_BIND_NOW:
7982 /* The value of this entry is ignored. */
35b1837e
AM		 7983 if (do_dynamic)
7984 putchar ('\n');
252b5132 7985 break;
103f02d3 7986
047b2264
JJ		 7987 case DT_GNU_PRELINKED:
7988 if (do_dynamic)
7989 {
2cf0635d 7990 struct tm * tmp;
91d6fa6a 7991 time_t atime = entry->d_un.d_val;
047b2264 7992
91d6fa6a 7993 tmp = gmtime (&atime);
047b2264
JJ		 7994 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7995 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7996 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7997
7998 }
7999 break;
8000
fdc90cb4
JJ		 8001 case DT_GNU_HASH:
8002 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8003 if (do_dynamic)
8004 {
8005 print_vma (entry->d_un.d_val, PREFIX_HEX);
8006 putchar ('\n');
8007 }
8008 break;
8009
252b5132
RH		 8010 default:
8011 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8012 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8013 entry->d_un.d_val;
8014
8015 if (do_dynamic)
8016 {
8017 switch (elf_header.e_machine)
8018 {
8019 case EM_MIPS:
4fe85591 8020 case EM_MIPS_RS3_LE:
b2d38a17 8021 dynamic_section_mips_val (entry);
252b5132 8022 break;
103f02d3 8023 case EM_PARISC:
b2d38a17 8024 dynamic_section_parisc_val (entry);
103f02d3 8025 break;
ecc51f48 8026 case EM_IA_64:
b2d38a17 8027 dynamic_section_ia64_val (entry);
ecc51f48 8028 break;
252b5132 8029 default:
f7a99963
NC		 8030 print_vma (entry->d_un.d_val, PREFIX_HEX);
8031 putchar ('\n');
252b5132
RH		 8032 }
8033 }
8034 break;
8035 }
8036 }
8037
8038 return 1;
8039}
8040
8041static char *
d3ba0551 8042get_ver_flags (unsigned int flags)
252b5132 8043{
b34976b6 8044 static char buff[32];
252b5132
RH		 8045
8046 buff[0] = 0;
8047
8048 if (flags == 0)
8049 return _("none");
8050
8051 if (flags & VER_FLG_BASE)
8052 strcat (buff, "BASE ");
8053
8054 if (flags & VER_FLG_WEAK)
8055 {
8056 if (flags & VER_FLG_BASE)
8057 strcat (buff, "| ");
8058
8059 strcat (buff, "WEAK ");
8060 }
8061
44ec90b9
RO		 8062 if (flags & VER_FLG_INFO)
8063 {
8064 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8065 strcat (buff, "| ");
8066
8067 strcat (buff, "INFO ");
8068 }
8069
8070 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8071 strcat (buff, _("| <unknown>"));
252b5132
RH		 8072
8073 return buff;
8074}
8075
8076/* Display the contents of the version sections. */
98fb390a 8077
252b5132 8078static int
2cf0635d 8079process_version_sections (FILE * file)
252b5132 8080{
2cf0635d 8081 Elf_Internal_Shdr * section;
b34976b6
AM		 8082 unsigned i;
8083 int found = 0;
252b5132
RH		 8084
8085 if (! do_version)
8086 return 1;
8087
8088 for (i = 0, section = section_headers;
8089 i < elf_header.e_shnum;
b34976b6 8090 i++, section++)
252b5132
RH		 8091 {
8092 switch (section->sh_type)
8093 {
8094 case SHT_GNU_verdef:
8095 {
2cf0635d 8096 Elf_External_Verdef * edefs;
b34976b6
AM		 8097 unsigned int idx;
8098 unsigned int cnt;
2cf0635d 8099 char * endbuf;
252b5132
RH		 8100
8101 found = 1;
8102
8103 printf
72de5009 8104 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8105 SECTION_NAME (section), section->sh_info);
8106
8107 printf (_(" Addr: 0x"));
8108 printf_vma (section->sh_addr);
72de5009 8109 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8110 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8111 section->sh_link < elf_header.e_shnum
8112 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8113 : _("<corrupt>"));
252b5132 8114
3f5e193b
NC		 8115 edefs = (Elf_External_Verdef *)
8116 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8117 _("version definition section"));
a6e9f9df
AM		 8118 if (!edefs)
8119 break;
59245841 8120 endbuf = (char *) edefs + section->sh_size;
252b5132 8121
b34976b6 8122 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8123 {
2cf0635d
NC		 8124 char * vstart;
8125 Elf_External_Verdef * edef;
b34976b6 8126 Elf_Internal_Verdef ent;
2cf0635d 8127 Elf_External_Verdaux * eaux;
b34976b6
AM		 8128 Elf_Internal_Verdaux aux;
8129 int j;
8130 int isum;
103f02d3 8131
dd24e3da
NC		 8132 /* Check for negative or very large indicies. */
8133 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8134 break;
8135
252b5132 8136 vstart = ((char *) edefs) + idx;
54806181
AM		 8137 if (vstart + sizeof (*edef) > endbuf)
8138 break;
252b5132
RH		 8139
8140 edef = (Elf_External_Verdef *) vstart;
8141
8142 ent.vd_version = BYTE_GET (edef->vd_version);
8143 ent.vd_flags = BYTE_GET (edef->vd_flags);
8144 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8145 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8146 ent.vd_hash = BYTE_GET (edef->vd_hash);
8147 ent.vd_aux = BYTE_GET (edef->vd_aux);
8148 ent.vd_next = BYTE_GET (edef->vd_next);
8149
8150 printf (_(" %#06x: Rev: %d Flags: %s"),
8151 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8152
8153 printf (_(" Index: %d Cnt: %d "),
8154 ent.vd_ndx, ent.vd_cnt);
8155
dd24e3da
NC		 8156 /* Check for overflow. */
8157 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8158 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8159 break;
8160
252b5132
RH		 8161 vstart += ent.vd_aux;
8162
8163 eaux = (Elf_External_Verdaux *) vstart;
8164
8165 aux.vda_name = BYTE_GET (eaux->vda_name);
8166 aux.vda_next = BYTE_GET (eaux->vda_next);
8167
d79b3d50
NC		 8168 if (VALID_DYNAMIC_NAME (aux.vda_name))
8169 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8170 else
8171 printf (_("Name index: %ld\n"), aux.vda_name);
8172
8173 isum = idx + ent.vd_aux;
8174
b34976b6 8175 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8176 {
dd24e3da
NC		 8177 /* Check for overflow. */
8178 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8179 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8180 break;
8181
252b5132
RH		 8182 isum += aux.vda_next;
8183 vstart += aux.vda_next;
8184
8185 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8186 if (vstart + sizeof (*eaux) > endbuf)
8187 break;
252b5132
RH		 8188
8189 aux.vda_name = BYTE_GET (eaux->vda_name);
8190 aux.vda_next = BYTE_GET (eaux->vda_next);
8191
d79b3d50 8192 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8193 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8194 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8195 else
8196 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8197 isum, j, aux.vda_name);
8198 }
dd24e3da 8199
54806181
AM		 8200 if (j < ent.vd_cnt)
8201 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8202
8203 idx += ent.vd_next;
8204 }
dd24e3da 8205
54806181
AM		 8206 if (cnt < section->sh_info)
8207 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8208
8209 free (edefs);
8210 }
8211 break;
103f02d3 8212
252b5132
RH		 8213 case SHT_GNU_verneed:
8214 {
2cf0635d 8215 Elf_External_Verneed * eneed;
b34976b6
AM		 8216 unsigned int idx;
8217 unsigned int cnt;
2cf0635d 8218 char * endbuf;
252b5132
RH		 8219
8220 found = 1;
8221
72de5009 8222 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8223 SECTION_NAME (section), section->sh_info);
8224
8225 printf (_(" Addr: 0x"));
8226 printf_vma (section->sh_addr);
72de5009 8227 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8228 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8229 section->sh_link < elf_header.e_shnum
8230 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8231 : _("<corrupt>"));
252b5132 8232
3f5e193b
NC		 8233 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8234 section->sh_offset, 1,
8235 section->sh_size,
8236 _("version need section"));
a6e9f9df
AM		 8237 if (!eneed)
8238 break;
59245841 8239 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8240
8241 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8242 {
2cf0635d 8243 Elf_External_Verneed * entry;
b34976b6
AM		 8244 Elf_Internal_Verneed ent;
8245 int j;
8246 int isum;
2cf0635d 8247 char * vstart;
252b5132 8248
dd24e3da
NC		 8249 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8250 break;
8251
252b5132 8252 vstart = ((char *) eneed) + idx;
54806181
AM		 8253 if (vstart + sizeof (*entry) > endbuf)
8254 break;
252b5132
RH		 8255
8256 entry = (Elf_External_Verneed *) vstart;
8257
8258 ent.vn_version = BYTE_GET (entry->vn_version);
8259 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8260 ent.vn_file = BYTE_GET (entry->vn_file);
8261 ent.vn_aux = BYTE_GET (entry->vn_aux);
8262 ent.vn_next = BYTE_GET (entry->vn_next);
8263
8264 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8265
d79b3d50
NC		 8266 if (VALID_DYNAMIC_NAME (ent.vn_file))
8267 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8268 else
8269 printf (_(" File: %lx"), ent.vn_file);
8270
8271 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8272
dd24e3da
NC		 8273 /* Check for overflow. */
8274 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8275 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8276 break;
8277
252b5132
RH		 8278 vstart += ent.vn_aux;
8279
8280 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8281 {
2cf0635d 8282 Elf_External_Vernaux * eaux;
b34976b6 8283 Elf_Internal_Vernaux aux;
252b5132 8284
54806181
AM		 8285 if (vstart + sizeof (*eaux) > endbuf)
8286 break;
252b5132
RH		 8287 eaux = (Elf_External_Vernaux *) vstart;
8288
8289 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8290 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8291 aux.vna_other = BYTE_GET (eaux->vna_other);
8292 aux.vna_name = BYTE_GET (eaux->vna_name);
8293 aux.vna_next = BYTE_GET (eaux->vna_next);
8294
d79b3d50 8295 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8296 printf (_(" %#06x: Name: %s"),
d79b3d50 8297 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8298 else
ecc2063b 8299 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8300 isum, aux.vna_name);
8301
8302 printf (_(" Flags: %s Version: %d\n"),
8303 get_ver_flags (aux.vna_flags), aux.vna_other);
8304
dd24e3da
NC		 8305 /* Check for overflow. */
8306 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8307 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8308 break;
8309
252b5132
RH		 8310 isum += aux.vna_next;
8311 vstart += aux.vna_next;
8312 }
54806181
AM		 8313 if (j < ent.vn_cnt)
8314 printf (_(" Version need aux past end of section\n"));
252b5132
RH		 8315
8316 idx += ent.vn_next;
8317 }
54806181
AM		 8318 if (cnt < section->sh_info)
8319 printf (_(" Version need past end of section\n"));
103f02d3 8320
252b5132
RH		 8321 free (eneed);
8322 }
8323 break;
8324
8325 case SHT_GNU_versym:
8326 {
2cf0635d 8327 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8328 int total;
8329 int cnt;
2cf0635d
NC		 8330 unsigned char * edata;
8331 unsigned short * data;
8332 char * strtab;
8333 Elf_Internal_Sym * symbols;
8334 Elf_Internal_Shdr * string_sec;
d3ba0551 8335 long off;
252b5132 8336
4fbb74a6 8337 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8338 break;
8339
4fbb74a6 8340 link_section = section_headers + section->sh_link;
08d8fa11 8341 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8342
4fbb74a6 8343 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8344 break;
8345
252b5132
RH		 8346 found = 1;
8347
9ad5cbcf 8348 symbols = GET_ELF_SYMBOLS (file, link_section);
dd24e3da
NC		 8349 if (symbols == NULL)
8350 break;
252b5132 8351
4fbb74a6 8352 string_sec = section_headers + link_section->sh_link;
252b5132 8353
3f5e193b
NC		 8354 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8355 string_sec->sh_size,
8356 _("version string table"));
a6e9f9df 8357 if (!strtab)
0429c154
MS		 8358 {
8359 free (symbols);
8360 break;
8361 }
252b5132
RH		 8362
8363 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8364 SECTION_NAME (section), total);
8365
8366 printf (_(" Addr: "));
8367 printf_vma (section->sh_addr);
72de5009 8368 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8369 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8370 SECTION_NAME (link_section));
8371
d3ba0551
AM		 8372 off = offset_from_vma (file,
8373 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8374 total * sizeof (short));
3f5e193b
NC		 8375 edata = (unsigned char *) get_data (NULL, file, off, total,
8376 sizeof (short),
8377 _("version symbol data"));
a6e9f9df
AM		 8378 if (!edata)
8379 {
8380 free (strtab);
0429c154 8381 free (symbols);
a6e9f9df
AM		 8382 break;
8383 }
252b5132 8384
3f5e193b 8385 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8386
8387 for (cnt = total; cnt --;)
b34976b6
AM		 8388 data[cnt] = byte_get (edata + cnt * sizeof (short),
8389 sizeof (short));
252b5132
RH		 8390
8391 free (edata);
8392
8393 for (cnt = 0; cnt < total; cnt += 4)
8394 {
8395 int j, nn;
00d93f34 8396 int check_def, check_need;
2cf0635d 8397 char * name;
252b5132
RH		 8398
8399 printf (" %03x:", cnt);
8400
8401 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8402 switch (data[cnt + j])
252b5132
RH		 8403 {
8404 case 0:
8405 fputs (_(" 0 (*local*) "), stdout);
8406 break;
8407
8408 case 1:
8409 fputs (_(" 1 (*global*) "), stdout);
8410 break;
8411
8412 default:
c244d050
NC		 8413 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8414 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8415
dd24e3da
NC		 8416 /* If this index value is greater than the size of the symbols
8417 array, break to avoid an out-of-bounds read, */
8418 if ((unsigned long)(cnt + j) >=
8419 ((unsigned long)link_section->sh_size /
8420 (unsigned long)link_section->sh_entsize))
8421 {
8422 warn (_("invalid index into symbol array\n"));
8423 break;
8424 }
8425
00d93f34
JJ		 8426 check_def = 1;
8427 check_need = 1;
4fbb74a6
AM		 8428 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8429 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8430 != SHT_NOBITS)
252b5132 8431 {
b34976b6 8432 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8433 check_def = 0;
8434 else
8435 check_need = 0;
252b5132 8436 }
00d93f34
JJ		 8437
8438 if (check_need
b34976b6 8439 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8440 {
b34976b6
AM		 8441 Elf_Internal_Verneed ivn;
8442 unsigned long offset;
252b5132 8443
d93f0186
NC		 8444 offset = offset_from_vma
8445 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8446 sizeof (Elf_External_Verneed));
252b5132 8447
b34976b6 8448 do
252b5132 8449 {
b34976b6
AM		 8450 Elf_Internal_Vernaux ivna;
8451 Elf_External_Verneed evn;
8452 Elf_External_Vernaux evna;
8453 unsigned long a_off;
252b5132 8454
59245841
NC		 8455 if (get_data (&evn, file, offset, sizeof (evn), 1,
8456 _("version need")) == NULL)
8457 break;
8458
252b5132
RH		 8459 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8460 ivn.vn_next = BYTE_GET (evn.vn_next);
8461
8462 a_off = offset + ivn.vn_aux;
8463
8464 do
8465 {
59245841
NC		 8466 if (get_data (&evna, file, a_off, sizeof (evna),
8467 1, _("version need aux (2)")) == NULL)
8468 {
8469 ivna.vna_next = 0;
8470 ivna.vna_other = 0;
8471 }
8472 else
8473 {
8474 ivna.vna_next = BYTE_GET (evna.vna_next);
8475 ivna.vna_other = BYTE_GET (evna.vna_other);
8476 }
252b5132
RH		 8477
8478 a_off += ivna.vna_next;
8479 }
b34976b6 8480 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8481 && ivna.vna_next != 0);
8482
b34976b6 8483 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8484 {
8485 ivna.vna_name = BYTE_GET (evna.vna_name);
8486
54806181
AM		 8487 if (ivna.vna_name >= string_sec->sh_size)
8488 name = _("*invalid*");
8489 else
8490 name = strtab + ivna.vna_name;
252b5132 8491 nn += printf ("(%s%-*s",
16062207
ILT		 8492 name,
8493 12 - (int) strlen (name),
252b5132 8494 ")");
00d93f34 8495 check_def = 0;
252b5132
RH		 8496 break;
8497 }
8498
8499 offset += ivn.vn_next;
8500 }
8501 while (ivn.vn_next);
8502 }
00d93f34 8503
b34976b6
AM		 8504 if (check_def && data[cnt + j] != 0x8001
8505 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8506 {
b34976b6
AM		 8507 Elf_Internal_Verdef ivd;
8508 Elf_External_Verdef evd;
8509 unsigned long offset;
252b5132 8510
d93f0186
NC		 8511 offset = offset_from_vma
8512 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8513 sizeof evd);
252b5132
RH		 8514
8515 do
8516 {
59245841
NC		 8517 if (get_data (&evd, file, offset, sizeof (evd), 1,
8518 _("version def")) == NULL)
8519 {
8520 ivd.vd_next = 0;
8521 ivd.vd_ndx = 0;
8522 }
8523 else
8524 {
8525 ivd.vd_next = BYTE_GET (evd.vd_next);
8526 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8527 }
252b5132
RH		 8528
8529 offset += ivd.vd_next;
8530 }
c244d050 8531 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8532 && ivd.vd_next != 0);
8533
c244d050 8534 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8535 {
b34976b6
AM		 8536 Elf_External_Verdaux evda;
8537 Elf_Internal_Verdaux ivda;
252b5132
RH		 8538
8539 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8540
59245841
NC		 8541 if (get_data (&evda, file,
8542 offset - ivd.vd_next + ivd.vd_aux,
8543 sizeof (evda), 1,
8544 _("version def aux")) == NULL)
8545 break;
252b5132
RH		 8546
8547 ivda.vda_name = BYTE_GET (evda.vda_name);
8548
54806181
AM		 8549 if (ivda.vda_name >= string_sec->sh_size)
8550 name = _("*invalid*");
8551 else
8552 name = strtab + ivda.vda_name;
252b5132 8553 nn += printf ("(%s%-*s",
16062207
ILT		 8554 name,
8555 12 - (int) strlen (name),
252b5132
RH		 8556 ")");
8557 }
8558 }
8559
8560 if (nn < 18)
8561 printf ("%*c", 18 - nn, ' ');
8562 }
8563
8564 putchar ('\n');
8565 }
8566
8567 free (data);
8568 free (strtab);
8569 free (symbols);
8570 }
8571 break;
103f02d3 8572
252b5132
RH		 8573 default:
8574 break;
8575 }
8576 }
8577
8578 if (! found)
8579 printf (_("\nNo version information found in this file.\n"));
8580
8581 return 1;
8582}
8583
d1133906 8584static const char *
d3ba0551 8585get_symbol_binding (unsigned int binding)
252b5132 8586{
b34976b6 8587 static char buff[32];
252b5132
RH		 8588
8589 switch (binding)
8590 {
b34976b6
AM		 8591 case STB_LOCAL: return "LOCAL";
8592 case STB_GLOBAL: return "GLOBAL";
8593 case STB_WEAK: return "WEAK";
252b5132
RH		 8594 default:
8595 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8596 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8597 binding);
252b5132 8598 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8599 {
8600 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8601 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8602 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8603 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8604 return "UNIQUE";
8605 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8606 }
252b5132 8607 else
e9e44622 8608 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8609 return buff;
8610 }
8611}
8612
d1133906 8613static const char *
d3ba0551 8614get_symbol_type (unsigned int type)
252b5132 8615{
b34976b6 8616 static char buff[32];
252b5132
RH		 8617
8618 switch (type)
8619 {
b34976b6
AM		 8620 case STT_NOTYPE: return "NOTYPE";
8621 case STT_OBJECT: return "OBJECT";
8622 case STT_FUNC: return "FUNC";
8623 case STT_SECTION: return "SECTION";
8624 case STT_FILE: return "FILE";
8625 case STT_COMMON: return "COMMON";
8626 case STT_TLS: return "TLS";
15ab5209
DB		 8627 case STT_RELC: return "RELC";
8628 case STT_SRELC: return "SRELC";
252b5132
RH		 8629 default:
8630 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8631 {
8632 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8633 return "THUMB_FUNC";
8634
351b4b40 8635 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8636 return "REGISTER";
8637
8638 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8639 return "PARISC_MILLI";
8640
e9e44622 8641 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8642 }
252b5132 8643 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8644 {
8645 if (elf_header.e_machine == EM_PARISC)
8646 {
8647 if (type == STT_HP_OPAQUE)
8648 return "HP_OPAQUE";
8649 if (type == STT_HP_STUB)
8650 return "HP_STUB";
8651 }
8652
d8045f23 8653 if (type == STT_GNU_IFUNC
9c55345c
TS		 8654 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8655 /* GNU is still using the default value 0. */
d8045f23
NC		 8656 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8657 return "IFUNC";
8658
e9e44622 8659 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8660 }
252b5132 8661 else
e9e44622 8662 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8663 return buff;
8664 }
8665}
8666
d1133906 8667static const char *
d3ba0551 8668get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8669{
8670 switch (visibility)
8671 {
b34976b6
AM		 8672 case STV_DEFAULT: return "DEFAULT";
8673 case STV_INTERNAL: return "INTERNAL";
8674 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8675 case STV_PROTECTED: return "PROTECTED";
8676 default: abort ();
8677 }
8678}
8679
5e2b0d47
NC		 8680static const char *
8681get_mips_symbol_other (unsigned int other)
8682{
8683 switch (other)
8684 {
df58fc94
RS		 8685 case STO_OPTIONAL:
8686 return "OPTIONAL";
8687 case STO_MIPS_PLT:
8688 return "MIPS PLT";
8689 case STO_MIPS_PIC:
8690 return "MIPS PIC";
8691 case STO_MICROMIPS:
8692 return "MICROMIPS";
8693 case STO_MICROMIPS | STO_MIPS_PIC:
8694 return "MICROMIPS, MIPS PIC";
8695 case STO_MIPS16:
8696 return "MIPS16";
8697 default:
8698 return NULL;
5e2b0d47
NC		 8699 }
8700}
8701
28f997cf
TG		 8702static const char *
8703get_ia64_symbol_other (unsigned int other)
8704{
8705 if (is_ia64_vms ())
8706 {
8707 static char res[32];
8708
8709 res[0] = 0;
8710
8711 /* Function types is for images and .STB files only. */
8712 switch (elf_header.e_type)
8713 {
8714 case ET_DYN:
8715 case ET_EXEC:
8716 switch (VMS_ST_FUNC_TYPE (other))
8717 {
8718 case VMS_SFT_CODE_ADDR:
8719 strcat (res, " CA");
8720 break;
8721 case VMS_SFT_SYMV_IDX:
8722 strcat (res, " VEC");
8723 break;
8724 case VMS_SFT_FD:
8725 strcat (res, " FD");
8726 break;
8727 case VMS_SFT_RESERVE:
8728 strcat (res, " RSV");
8729 break;
8730 default:
8731 abort ();
8732 }
8733 break;
8734 default:
8735 break;
8736 }
8737 switch (VMS_ST_LINKAGE (other))
8738 {
8739 case VMS_STL_IGNORE:
8740 strcat (res, " IGN");
8741 break;
8742 case VMS_STL_RESERVE:
8743 strcat (res, " RSV");
8744 break;
8745 case VMS_STL_STD:
8746 strcat (res, " STD");
8747 break;
8748 case VMS_STL_LNK:
8749 strcat (res, " LNK");
8750 break;
8751 default:
8752 abort ();
8753 }
8754
8755 if (res[0] != 0)
8756 return res + 1;
8757 else
8758 return res;
8759 }
8760 return NULL;
8761}
8762
5e2b0d47
NC		 8763static const char *
8764get_symbol_other (unsigned int other)
8765{
8766 const char * result = NULL;
8767 static char buff [32];
8768
8769 if (other == 0)
8770 return "";
8771
8772 switch (elf_header.e_machine)
8773 {
8774 case EM_MIPS:
8775 result = get_mips_symbol_other (other);
28f997cf
TG		 8776 break;
8777 case EM_IA_64:
8778 result = get_ia64_symbol_other (other);
8779 break;
5e2b0d47
NC		 8780 default:
8781 break;
8782 }
8783
8784 if (result)
8785 return result;
8786
8787 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8788 return buff;
8789}
8790
d1133906 8791static const char *
d3ba0551 8792get_symbol_index_type (unsigned int type)
252b5132 8793{
b34976b6 8794 static char buff[32];
5cf1065c 8795
252b5132
RH		 8796 switch (type)
8797 {
b34976b6
AM		 8798 case SHN_UNDEF: return "UND";
8799 case SHN_ABS: return "ABS";
8800 case SHN_COMMON: return "COM";
252b5132 8801 default:
9ce701e2
L		 8802 if (type == SHN_IA_64_ANSI_COMMON
8803 && elf_header.e_machine == EM_IA_64
8804 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8805 return "ANSI_COM";
8a9036a4 8806 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 8807 || elf_header.e_machine == EM_L1OM
8808 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 8809 && type == SHN_X86_64_LCOMMON)
8810 return "LARGE_COM";
ac145307
BS		 8811 else if ((type == SHN_MIPS_SCOMMON
8812 && elf_header.e_machine == EM_MIPS)
8813 || (type == SHN_TIC6X_SCOMMON
8814 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8815 return "SCOM";
8816 else if (type == SHN_MIPS_SUNDEFINED
8817 && elf_header.e_machine == EM_MIPS)
8818 return "SUND";
9ce701e2 8819 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8820 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8821 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8822 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8823 else if (type >= SHN_LORESERVE)
8824 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
252b5132 8825 else
232e7cb8 8826 sprintf (buff, "%3d", type);
5cf1065c 8827 break;
252b5132 8828 }
5cf1065c
NC		 8829
8830 return buff;
252b5132
RH		 8831}
8832
66543521 8833static bfd_vma *
2cf0635d 8834get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8835{
2cf0635d
NC		 8836 unsigned char * e_data;
8837 bfd_vma * i_data;
252b5132 8838
3f5e193b 8839 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8840
8841 if (e_data == NULL)
8842 {
8843 error (_("Out of memory\n"));
8844 return NULL;
8845 }
8846
66543521 8847 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 8848 {
8849 error (_("Unable to read in dynamic data\n"));
8850 return NULL;
8851 }
8852
3f5e193b 8853 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 8854
8855 if (i_data == NULL)
8856 {
8857 error (_("Out of memory\n"));
8858 free (e_data);
8859 return NULL;
8860 }
8861
8862 while (number--)
66543521 8863 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 8864
8865 free (e_data);
8866
8867 return i_data;
8868}
8869
6bd1a22c
L		 8870static void
8871print_dynamic_symbol (bfd_vma si, unsigned long hn)
8872{
2cf0635d 8873 Elf_Internal_Sym * psym;
6bd1a22c
L		 8874 int n;
8875
8876 psym = dynamic_symbols + si;
8877
8878 n = print_vma (si, DEC_5);
8879 if (n < 5)
8880 fputs (" " + n, stdout);
8881 printf (" %3lu: ", hn);
8882 print_vma (psym->st_value, LONG_HEX);
8883 putchar (' ');
8884 print_vma (psym->st_size, DEC_5);
8885
f4be36b3
AM		 8886 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8887 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8888 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 8889 /* Check to see if any other bits in the st_other field are set.
8890 Note - displaying this information disrupts the layout of the
8891 table being generated, but for the moment this case is very
8892 rare. */
8893 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8894 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8895 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8896 if (VALID_DYNAMIC_NAME (psym->st_name))
8897 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8898 else
2b692964 8899 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 8900 putchar ('\n');
8901}
8902
e3c8793a 8903/* Dump the symbol table. */
252b5132 8904static int
2cf0635d 8905process_symbol_table (FILE * file)
252b5132 8906{
2cf0635d 8907 Elf_Internal_Shdr * section;
66543521
AM		 8908 bfd_vma nbuckets = 0;
8909 bfd_vma nchains = 0;
2cf0635d
NC		 8910 bfd_vma * buckets = NULL;
8911 bfd_vma * chains = NULL;
fdc90cb4 8912 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 8913 bfd_vma * gnubuckets = NULL;
8914 bfd_vma * gnuchains = NULL;
6bd1a22c 8915 bfd_vma gnusymidx = 0;
252b5132 8916
2c610e4b 8917 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 8918 return 1;
8919
6bd1a22c
L		 8920 if (dynamic_info[DT_HASH]
8921 && (do_histogram
2c610e4b
L		 8922 || (do_using_dynamic
8923 && !do_dyn_syms
8924 && dynamic_strings != NULL)))
252b5132 8925 {
66543521
AM		 8926 unsigned char nb[8];
8927 unsigned char nc[8];
8928 int hash_ent_size = 4;
8929
8930 if ((elf_header.e_machine == EM_ALPHA
8931 || elf_header.e_machine == EM_S390
8932 || elf_header.e_machine == EM_S390_OLD)
8933 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8934 hash_ent_size = 8;
8935
fb52b2f4
NC		 8936 if (fseek (file,
8937 (archive_file_offset
8938 + offset_from_vma (file, dynamic_info[DT_HASH],
8939 sizeof nb + sizeof nc)),
d93f0186 8940 SEEK_SET))
252b5132 8941 {
591a748a 8942 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8943 goto no_hash;
252b5132
RH		 8944 }
8945
66543521 8946 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 8947 {
8948 error (_("Failed to read in number of buckets\n"));
d3a44ec6 8949 goto no_hash;
252b5132
RH		 8950 }
8951
66543521 8952 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 8953 {
8954 error (_("Failed to read in number of chains\n"));
d3a44ec6 8955 goto no_hash;
252b5132
RH		 8956 }
8957
66543521
AM		 8958 nbuckets = byte_get (nb, hash_ent_size);
8959 nchains = byte_get (nc, hash_ent_size);
252b5132 8960
66543521
AM		 8961 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8962 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 8963
d3a44ec6 8964 no_hash:
252b5132 8965 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 8966 {
8967 if (do_using_dynamic)
8968 return 0;
8969 free (buckets);
8970 free (chains);
8971 buckets = NULL;
8972 chains = NULL;
8973 nbuckets = 0;
8974 nchains = 0;
8975 }
252b5132
RH		 8976 }
8977
6bd1a22c
L		 8978 if (dynamic_info_DT_GNU_HASH
8979 && (do_histogram
2c610e4b
L		 8980 || (do_using_dynamic
8981 && !do_dyn_syms
8982 && dynamic_strings != NULL)))
252b5132 8983 {
6bd1a22c
L		 8984 unsigned char nb[16];
8985 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8986 bfd_vma buckets_vma;
8987
8988 if (fseek (file,
8989 (archive_file_offset
8990 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8991 sizeof nb)),
8992 SEEK_SET))
8993 {
8994 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 8995 goto no_gnu_hash;
6bd1a22c 8996 }
252b5132 8997
6bd1a22c
L		 8998 if (fread (nb, 16, 1, file) != 1)
8999 {
9000 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9001 goto no_gnu_hash;
6bd1a22c
L		 9002 }
9003
9004 ngnubuckets = byte_get (nb, 4);
9005 gnusymidx = byte_get (nb + 4, 4);
9006 bitmaskwords = byte_get (nb + 8, 4);
9007 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9008 if (is_32bit_elf)
6bd1a22c 9009 buckets_vma += bitmaskwords * 4;
f7a99963 9010 else
6bd1a22c 9011 buckets_vma += bitmaskwords * 8;
252b5132 9012
6bd1a22c
L		 9013 if (fseek (file,
9014 (archive_file_offset
9015 + offset_from_vma (file, buckets_vma, 4)),
9016 SEEK_SET))
252b5132 9017 {
6bd1a22c 9018 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9019 goto no_gnu_hash;
6bd1a22c
L		 9020 }
9021
9022 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9023
6bd1a22c 9024 if (gnubuckets == NULL)
d3a44ec6 9025 goto no_gnu_hash;
6bd1a22c
L		 9026
9027 for (i = 0; i < ngnubuckets; i++)
9028 if (gnubuckets[i] != 0)
9029 {
9030 if (gnubuckets[i] < gnusymidx)
9031 return 0;
9032
9033 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9034 maxchain = gnubuckets[i];
9035 }
9036
9037 if (maxchain == 0xffffffff)
d3a44ec6 9038 goto no_gnu_hash;
6bd1a22c
L		 9039
9040 maxchain -= gnusymidx;
9041
9042 if (fseek (file,
9043 (archive_file_offset
9044 + offset_from_vma (file, buckets_vma
9045 + 4 * (ngnubuckets + maxchain), 4)),
9046 SEEK_SET))
9047 {
9048 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9049 goto no_gnu_hash;
6bd1a22c
L		 9050 }
9051
9052 do
9053 {
9054 if (fread (nb, 4, 1, file) != 1)
252b5132 9055 {
6bd1a22c 9056 error (_("Failed to determine last chain length\n"));
d3a44ec6 9057 goto no_gnu_hash;
6bd1a22c 9058 }
252b5132 9059
6bd1a22c 9060 if (maxchain + 1 == 0)
d3a44ec6 9061 goto no_gnu_hash;
252b5132 9062
6bd1a22c
L		 9063 ++maxchain;
9064 }
9065 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9066
6bd1a22c
L		 9067 if (fseek (file,
9068 (archive_file_offset
9069 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9070 SEEK_SET))
9071 {
9072 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9073 goto no_gnu_hash;
6bd1a22c
L		 9074 }
9075
9076 gnuchains = get_dynamic_data (file, maxchain, 4);
9077
d3a44ec6 9078 no_gnu_hash:
6bd1a22c 9079 if (gnuchains == NULL)
d3a44ec6
JJ		 9080 {
9081 free (gnubuckets);
d3a44ec6
JJ		 9082 gnubuckets = NULL;
9083 ngnubuckets = 0;
f64fddf1
NC		 9084 if (do_using_dynamic)
9085 return 0;
d3a44ec6 9086 }
6bd1a22c
L		 9087 }
9088
9089 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9090 && do_syms
9091 && do_using_dynamic
9092 && dynamic_strings != NULL)
9093 {
9094 unsigned long hn;
9095
9096 if (dynamic_info[DT_HASH])
9097 {
9098 bfd_vma si;
9099
9100 printf (_("\nSymbol table for image:\n"));
9101 if (is_32bit_elf)
9102 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9103 else
9104 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9105
9106 for (hn = 0; hn < nbuckets; hn++)
9107 {
9108 if (! buckets[hn])
9109 continue;
9110
9111 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9112 print_dynamic_symbol (si, hn);
252b5132
RH		 9113 }
9114 }
6bd1a22c
L		 9115
9116 if (dynamic_info_DT_GNU_HASH)
9117 {
9118 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9119 if (is_32bit_elf)
9120 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9121 else
9122 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9123
9124 for (hn = 0; hn < ngnubuckets; ++hn)
9125 if (gnubuckets[hn] != 0)
9126 {
9127 bfd_vma si = gnubuckets[hn];
9128 bfd_vma off = si - gnusymidx;
9129
9130 do
9131 {
9132 print_dynamic_symbol (si, hn);
9133 si++;
9134 }
9135 while ((gnuchains[off++] & 1) == 0);
9136 }
9137 }
252b5132 9138 }
2c610e4b 9139 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9140 {
b34976b6 9141 unsigned int i;
252b5132
RH		 9142
9143 for (i = 0, section = section_headers;
9144 i < elf_header.e_shnum;
9145 i++, section++)
9146 {
b34976b6 9147 unsigned int si;
2cf0635d 9148 char * strtab = NULL;
c256ffe7 9149 unsigned long int strtab_size = 0;
2cf0635d
NC		 9150 Elf_Internal_Sym * symtab;
9151 Elf_Internal_Sym * psym;
252b5132 9152
2c610e4b
L		 9153 if ((section->sh_type != SHT_SYMTAB
9154 && section->sh_type != SHT_DYNSYM)
9155 || (!do_syms
9156 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9157 continue;
9158
dd24e3da
NC		 9159 if (section->sh_entsize == 0)
9160 {
9161 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9162 SECTION_NAME (section));
9163 continue;
9164 }
9165
252b5132
RH		 9166 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9167 SECTION_NAME (section),
9168 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9169
f7a99963 9170 if (is_32bit_elf)
ca47b30c 9171 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9172 else
ca47b30c 9173 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9174
9ad5cbcf 9175 symtab = GET_ELF_SYMBOLS (file, section);
252b5132
RH		 9176 if (symtab == NULL)
9177 continue;
9178
9179 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9180 {
9181 strtab = string_table;
9182 strtab_size = string_table_length;
9183 }
4fbb74a6 9184 else if (section->sh_link < elf_header.e_shnum)
252b5132 9185 {
2cf0635d 9186 Elf_Internal_Shdr * string_sec;
252b5132 9187
4fbb74a6 9188 string_sec = section_headers + section->sh_link;
252b5132 9189
3f5e193b
NC		 9190 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9191 1, string_sec->sh_size,
9192 _("string table"));
c256ffe7 9193 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9194 }
9195
9196 for (si = 0, psym = symtab;
9197 si < section->sh_size / section->sh_entsize;
b34976b6 9198 si++, psym++)
252b5132 9199 {
5e220199 9200 printf ("%6d: ", si);
f7a99963
NC		 9201 print_vma (psym->st_value, LONG_HEX);
9202 putchar (' ');
9203 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9204 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9205 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9206 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9207 /* Check to see if any other bits in the st_other field are set.
9208 Note - displaying this information disrupts the layout of the
9209 table being generated, but for the moment this case is very rare. */
9210 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9211 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9212 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9213 print_symbol (25, psym->st_name < strtab_size
2b692964 9214 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9215
59245841
NC		 9216 if (section->sh_type == SHT_DYNSYM
9217 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9218 {
b34976b6
AM		 9219 unsigned char data[2];
9220 unsigned short vers_data;
9221 unsigned long offset;
9222 int is_nobits;
9223 int check_def;
252b5132 9224
d93f0186
NC		 9225 offset = offset_from_vma
9226 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9227 sizeof data + si * sizeof (vers_data));
252b5132 9228
59245841
NC		 9229 if (get_data (&data, file, offset + si * sizeof (vers_data),
9230 sizeof (data), 1, _("version data")) == NULL)
9231 break;
252b5132
RH		 9232
9233 vers_data = byte_get (data, 2);
9234
4fbb74a6
AM		 9235 is_nobits = (psym->st_shndx < elf_header.e_shnum
9236 && section_headers[psym->st_shndx].sh_type
c256ffe7 9237 == SHT_NOBITS);
252b5132
RH		 9238
9239 check_def = (psym->st_shndx != SHN_UNDEF);
9240
c244d050 9241 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9242 {
b34976b6 9243 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9244 && (is_nobits || ! check_def))
252b5132 9245 {
b34976b6
AM		 9246 Elf_External_Verneed evn;
9247 Elf_Internal_Verneed ivn;
9248 Elf_Internal_Vernaux ivna;
252b5132
RH		 9249
9250 /* We must test both. */
d93f0186
NC		 9251 offset = offset_from_vma
9252 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9253 sizeof evn);
252b5132 9254
252b5132
RH		 9255 do
9256 {
b34976b6 9257 unsigned long vna_off;
252b5132 9258
59245841
NC		 9259 if (get_data (&evn, file, offset, sizeof (evn), 1,
9260 _("version need")) == NULL)
9261 {
9262 ivna.vna_next = 0;
9263 ivna.vna_other = 0;
9264 ivna.vna_name = 0;
9265 break;
9266 }
dd27201e
L		 9267
9268 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9269 ivn.vn_next = BYTE_GET (evn.vn_next);
9270
252b5132
RH		 9271 vna_off = offset + ivn.vn_aux;
9272
9273 do
9274 {
b34976b6 9275 Elf_External_Vernaux evna;
252b5132 9276
59245841
NC		 9277 if (get_data (&evna, file, vna_off,
9278 sizeof (evna), 1,
9279 _("version need aux (3)")) == NULL)
9280 {
9281 ivna.vna_next = 0;
9282 ivna.vna_other = 0;
9283 ivna.vna_name = 0;
9284 }
9285 else
9286 {
9287 ivna.vna_other = BYTE_GET (evna.vna_other);
9288 ivna.vna_next = BYTE_GET (evna.vna_next);
9289 ivna.vna_name = BYTE_GET (evna.vna_name);
9290 }
252b5132
RH		 9291
9292 vna_off += ivna.vna_next;
9293 }
9294 while (ivna.vna_other != vers_data
9295 && ivna.vna_next != 0);
9296
9297 if (ivna.vna_other == vers_data)
9298 break;
9299
9300 offset += ivn.vn_next;
9301 }
9302 while (ivn.vn_next != 0);
9303
9304 if (ivna.vna_other == vers_data)
9305 {
9306 printf ("@%s (%d)",
c256ffe7 9307 ivna.vna_name < strtab_size
2b692964 9308 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9309 ivna.vna_other);
252b5132
RH		 9310 check_def = 0;
9311 }
9312 else if (! is_nobits)
591a748a 9313 error (_("bad dynamic symbol\n"));
252b5132
RH		 9314 else
9315 check_def = 1;
9316 }
9317
9318 if (check_def)
9319 {
00d93f34 9320 if (vers_data != 0x8001
b34976b6 9321 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9322 {
b34976b6
AM		 9323 Elf_Internal_Verdef ivd;
9324 Elf_Internal_Verdaux ivda;
9325 Elf_External_Verdaux evda;
91d6fa6a 9326 unsigned long off;
252b5132 9327
91d6fa6a 9328 off = offset_from_vma
d93f0186
NC		 9329 (file,
9330 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9331 sizeof (Elf_External_Verdef));
252b5132
RH		 9332
9333 do
9334 {
b34976b6 9335 Elf_External_Verdef evd;
252b5132 9336
59245841
NC		 9337 if (get_data (&evd, file, off, sizeof (evd),
9338 1, _("version def")) == NULL)
9339 {
9340 ivd.vd_ndx = 0;
9341 ivd.vd_aux = 0;
9342 ivd.vd_next = 0;
9343 }
9344 else
9345 {
9346 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9347 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9348 ivd.vd_next = BYTE_GET (evd.vd_next);
9349 }
252b5132 9350
91d6fa6a 9351 off += ivd.vd_next;
252b5132 9352 }
c244d050 9353 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9354 && ivd.vd_next != 0);
9355
91d6fa6a
NC		 9356 off -= ivd.vd_next;
9357 off += ivd.vd_aux;
252b5132 9358
59245841
NC		 9359 if (get_data (&evda, file, off, sizeof (evda),
9360 1, _("version def aux")) == NULL)
9361 break;
252b5132
RH		 9362
9363 ivda.vda_name = BYTE_GET (evda.vda_name);
9364
9365 if (psym->st_name != ivda.vda_name)
c244d050 9366 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9367 ? "@%s" : "@@%s",
c256ffe7 9368 ivda.vda_name < strtab_size
2b692964 9369 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9370 }
9371 }
9372 }
9373 }
9374
9375 putchar ('\n');
9376 }
9377
9378 free (symtab);
9379 if (strtab != string_table)
9380 free (strtab);
9381 }
9382 }
9383 else if (do_syms)
9384 printf
9385 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9386
9387 if (do_histogram && buckets != NULL)
9388 {
2cf0635d
NC		 9389 unsigned long * lengths;
9390 unsigned long * counts;
66543521
AM		 9391 unsigned long hn;
9392 bfd_vma si;
9393 unsigned long maxlength = 0;
9394 unsigned long nzero_counts = 0;
9395 unsigned long nsyms = 0;
252b5132 9396
66543521
AM		 9397 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9398 (unsigned long) nbuckets);
252b5132
RH		 9399 printf (_(" Length Number %% of total Coverage\n"));
9400
3f5e193b 9401 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9402 if (lengths == NULL)
9403 {
591a748a 9404 error (_("Out of memory\n"));
252b5132
RH		 9405 return 0;
9406 }
9407 for (hn = 0; hn < nbuckets; ++hn)
9408 {
f7a99963 9409 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9410 {
b34976b6 9411 ++nsyms;
252b5132 9412 if (maxlength < ++lengths[hn])
b34976b6 9413 ++maxlength;
252b5132
RH		 9414 }
9415 }
9416
3f5e193b 9417 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9418 if (counts == NULL)
9419 {
591a748a 9420 error (_("Out of memory\n"));
252b5132
RH		 9421 return 0;
9422 }
9423
9424 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9425 ++counts[lengths[hn]];
252b5132 9426
103f02d3 9427 if (nbuckets > 0)
252b5132 9428 {
66543521
AM		 9429 unsigned long i;
9430 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9431 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9432 for (i = 1; i <= maxlength; ++i)
103f02d3 9433 {
66543521
AM		 9434 nzero_counts += counts[i] * i;
9435 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9436 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9437 (nzero_counts * 100.0) / nsyms);
9438 }
252b5132
RH		 9439 }
9440
9441 free (counts);
9442 free (lengths);
9443 }
9444
9445 if (buckets != NULL)
9446 {
9447 free (buckets);
9448 free (chains);
9449 }
9450
d3a44ec6 9451 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9452 {
2cf0635d
NC		 9453 unsigned long * lengths;
9454 unsigned long * counts;
fdc90cb4
JJ		 9455 unsigned long hn;
9456 unsigned long maxlength = 0;
9457 unsigned long nzero_counts = 0;
9458 unsigned long nsyms = 0;
fdc90cb4 9459
3f5e193b 9460 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9461 if (lengths == NULL)
9462 {
591a748a 9463 error (_("Out of memory\n"));
fdc90cb4
JJ		 9464 return 0;
9465 }
9466
9467 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9468 (unsigned long) ngnubuckets);
9469 printf (_(" Length Number %% of total Coverage\n"));
9470
9471 for (hn = 0; hn < ngnubuckets; ++hn)
9472 if (gnubuckets[hn] != 0)
9473 {
9474 bfd_vma off, length = 1;
9475
6bd1a22c 9476 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9477 (gnuchains[off] & 1) == 0; ++off)
9478 ++length;
9479 lengths[hn] = length;
9480 if (length > maxlength)
9481 maxlength = length;
9482 nsyms += length;
9483 }
9484
3f5e193b 9485 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9486 if (counts == NULL)
9487 {
591a748a 9488 error (_("Out of memory\n"));
fdc90cb4
JJ		 9489 return 0;
9490 }
9491
9492 for (hn = 0; hn < ngnubuckets; ++hn)
9493 ++counts[lengths[hn]];
9494
9495 if (ngnubuckets > 0)
9496 {
9497 unsigned long j;
9498 printf (" 0 %-10lu (%5.1f%%)\n",
9499 counts[0], (counts[0] * 100.0) / ngnubuckets);
9500 for (j = 1; j <= maxlength; ++j)
9501 {
9502 nzero_counts += counts[j] * j;
9503 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9504 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9505 (nzero_counts * 100.0) / nsyms);
9506 }
9507 }
9508
9509 free (counts);
9510 free (lengths);
9511 free (gnubuckets);
9512 free (gnuchains);
9513 }
9514
252b5132
RH		 9515 return 1;
9516}
9517
9518static int
2cf0635d 9519process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9520{
b4c96d0d 9521 unsigned int i;
252b5132
RH		 9522
9523 if (dynamic_syminfo == NULL
9524 || !do_dynamic)
9525 /* No syminfo, this is ok. */
9526 return 1;
9527
9528 /* There better should be a dynamic symbol section. */
9529 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9530 return 0;
9531
9532 if (dynamic_addr)
9533 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9534 dynamic_syminfo_offset, dynamic_syminfo_nent);
9535
9536 printf (_(" Num: Name BoundTo Flags\n"));
9537 for (i = 0; i < dynamic_syminfo_nent; ++i)
9538 {
9539 unsigned short int flags = dynamic_syminfo[i].si_flags;
9540
31104126 9541 printf ("%4d: ", i);
d79b3d50
NC		 9542 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9543 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9544 else
2b692964 9545 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9546 putchar (' ');
252b5132
RH		 9547
9548 switch (dynamic_syminfo[i].si_boundto)
9549 {
9550 case SYMINFO_BT_SELF:
9551 fputs ("SELF ", stdout);
9552 break;
9553 case SYMINFO_BT_PARENT:
9554 fputs ("PARENT ", stdout);
9555 break;
9556 default:
9557 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9558 && dynamic_syminfo[i].si_boundto < dynamic_nent
9559 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9560 {
d79b3d50 9561 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9562 putchar (' ' );
9563 }
252b5132
RH		 9564 else
9565 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9566 break;
9567 }
9568
9569 if (flags & SYMINFO_FLG_DIRECT)
9570 printf (" DIRECT");
9571 if (flags & SYMINFO_FLG_PASSTHRU)
9572 printf (" PASSTHRU");
9573 if (flags & SYMINFO_FLG_COPY)
9574 printf (" COPY");
9575 if (flags & SYMINFO_FLG_LAZYLOAD)
9576 printf (" LAZYLOAD");
9577
9578 puts ("");
9579 }
9580
9581 return 1;
9582}
9583
cf13d699
NC		 9584/* Check to see if the given reloc needs to be handled in a target specific
9585 manner. If so then process the reloc and return TRUE otherwise return
9586 FALSE. */
09c11c86 9587
cf13d699
NC		 9588static bfd_boolean
9589target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9590 unsigned char * start,
9591 Elf_Internal_Sym * symtab)
252b5132 9592{
cf13d699 9593 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9594
cf13d699 9595 switch (elf_header.e_machine)
252b5132 9596 {
cf13d699
NC		 9597 case EM_MN10300:
9598 case EM_CYGNUS_MN10300:
9599 {
9600 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9601
cf13d699
NC		 9602 switch (reloc_type)
9603 {
9604 case 34: /* R_MN10300_ALIGN */
9605 return TRUE;
9606 case 33: /* R_MN10300_SYM_DIFF */
9607 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9608 return TRUE;
9609 case 1: /* R_MN10300_32 */
9610 case 2: /* R_MN10300_16 */
9611 if (saved_sym != NULL)
9612 {
9613 bfd_vma value;
252b5132 9614
cf13d699
NC		 9615 value = reloc->r_addend
9616 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9617 - saved_sym->st_value);
252b5132 9618
cf13d699 9619 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9620
cf13d699
NC		 9621 saved_sym = NULL;
9622 return TRUE;
9623 }
9624 break;
9625 default:
9626 if (saved_sym != NULL)
9627 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9628 break;
9629 }
9630 break;
9631 }
252b5132
RH		 9632 }
9633
cf13d699 9634 return FALSE;
252b5132
RH		 9635}
9636
aca88567
NC		 9637/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9638 DWARF debug sections. This is a target specific test. Note - we do not
9639 go through the whole including-target-headers-multiple-times route, (as
9640 we have already done with <elf/h8.h>) because this would become very
9641 messy and even then this function would have to contain target specific
9642 information (the names of the relocs instead of their numeric values).
9643 FIXME: This is not the correct way to solve this problem. The proper way
9644 is to have target specific reloc sizing and typing functions created by
9645 the reloc-macros.h header, in the same way that it already creates the
9646 reloc naming functions. */
9647
9648static bfd_boolean
9649is_32bit_abs_reloc (unsigned int reloc_type)
9650{
9651 switch (elf_header.e_machine)
9652 {
41e92641
NC		 9653 case EM_386:
9654 case EM_486:
9655 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9656 case EM_68K:
9657 return reloc_type == 1; /* R_68K_32. */
9658 case EM_860:
9659 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9660 case EM_960:
9661 return reloc_type == 2; /* R_960_32. */
aca88567 9662 case EM_ALPHA:
137b6b5f 9663 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9664 case EM_ARC:
9665 return reloc_type == 1; /* R_ARC_32. */
9666 case EM_ARM:
9667 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9668 case EM_AVR_OLD:
aca88567
NC		 9669 case EM_AVR:
9670 return reloc_type == 1;
9671 case EM_BLACKFIN:
9672 return reloc_type == 0x12; /* R_byte4_data. */
9673 case EM_CRIS:
9674 return reloc_type == 3; /* R_CRIS_32. */
9675 case EM_CR16:
6c03b1ed 9676 case EM_CR16_OLD:
aca88567
NC		 9677 return reloc_type == 3; /* R_CR16_NUM32. */
9678 case EM_CRX:
9679 return reloc_type == 15; /* R_CRX_NUM32. */
9680 case EM_CYGNUS_FRV:
9681 return reloc_type == 1;
41e92641
NC		 9682 case EM_CYGNUS_D10V:
9683 case EM_D10V:
9684 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9685 case EM_CYGNUS_D30V:
9686 case EM_D30V:
9687 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9688 case EM_DLX:
9689 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9690 case EM_CYGNUS_FR30:
9691 case EM_FR30:
9692 return reloc_type == 3; /* R_FR30_32. */
9693 case EM_H8S:
9694 case EM_H8_300:
9695 case EM_H8_300H:
9696 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9697 case EM_IA_64:
9698 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9699 case EM_IP2K_OLD:
9700 case EM_IP2K:
9701 return reloc_type == 2; /* R_IP2K_32. */
9702 case EM_IQ2000:
9703 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9704 case EM_LATTICEMICO32:
9705 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9706 case EM_M32C_OLD:
aca88567
NC		 9707 case EM_M32C:
9708 return reloc_type == 3; /* R_M32C_32. */
9709 case EM_M32R:
9710 return reloc_type == 34; /* R_M32R_32_RELA. */
9711 case EM_MCORE:
9712 return reloc_type == 1; /* R_MCORE_ADDR32. */
9713 case EM_CYGNUS_MEP:
9714 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9715 case EM_MICROBLAZE:
9716 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9717 case EM_MIPS:
9718 return reloc_type == 2; /* R_MIPS_32. */
9719 case EM_MMIX:
9720 return reloc_type == 4; /* R_MMIX_32. */
9721 case EM_CYGNUS_MN10200:
9722 case EM_MN10200:
9723 return reloc_type == 1; /* R_MN10200_32. */
9724 case EM_CYGNUS_MN10300:
9725 case EM_MN10300:
9726 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9727 case EM_MOXIE:
9728 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9729 case EM_MSP430_OLD:
9730 case EM_MSP430:
9731 return reloc_type == 1; /* R_MSP43_32. */
9732 case EM_MT:
9733 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9734 case EM_ALTERA_NIOS2:
9735 case EM_NIOS32:
9736 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9737 case EM_OPENRISC:
9738 case EM_OR32:
9739 return reloc_type == 1; /* R_OR32_32. */
aca88567 9740 case EM_PARISC:
5fda8eca
NC		 9741 return (reloc_type == 1 /* R_PARISC_DIR32. */
9742 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9743 case EM_PJ:
9744 case EM_PJ_OLD:
9745 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9746 case EM_PPC64:
9747 return reloc_type == 1; /* R_PPC64_ADDR32. */
9748 case EM_PPC:
9749 return reloc_type == 1; /* R_PPC_ADDR32. */
c7927a3c
NC		 9750 case EM_RX:
9751 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9752 case EM_S370:
9753 return reloc_type == 1; /* R_I370_ADDR31. */
9754 case EM_S390_OLD:
9755 case EM_S390:
9756 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9757 case EM_SCORE:
9758 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9759 case EM_SH:
9760 return reloc_type == 1; /* R_SH_DIR32. */
9761 case EM_SPARC32PLUS:
9762 case EM_SPARCV9:
9763 case EM_SPARC:
9764 return reloc_type == 3 /* R_SPARC_32. */
9765 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9766 case EM_SPU:
9767 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9768 case EM_TI_C6000:
9769 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9770 case EM_TILEGX:
9771 return reloc_type == 2; /* R_TILEGX_32. */
9772 case EM_TILEPRO:
9773 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9774 case EM_CYGNUS_V850:
9775 case EM_V850:
9776 return reloc_type == 6; /* R_V850_ABS32. */
9777 case EM_VAX:
9778 return reloc_type == 1; /* R_VAX_32. */
9779 case EM_X86_64:
8a9036a4 9780 case EM_L1OM:
7a9068fe 9781 case EM_K1OM:
aca88567 9782 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9783 case EM_XC16X:
9784 case EM_C166:
9785 return reloc_type == 3; /* R_XC16C_ABS_32. */
aca88567
NC		 9786 case EM_XSTORMY16:
9787 return reloc_type == 1; /* R_XSTROMY16_32. */
9788 case EM_XTENSA_OLD:
9789 case EM_XTENSA:
9790 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9791 default:
9792 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9793 elf_header.e_machine);
9794 abort ();
9795 }
9796}
9797
9798/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9799 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9800
9801static bfd_boolean
9802is_32bit_pcrel_reloc (unsigned int reloc_type)
9803{
9804 switch (elf_header.e_machine)
9805 {
41e92641
NC		 9806 case EM_386:
9807 case EM_486:
3e0873ac 9808 return reloc_type == 2; /* R_386_PC32. */
aca88567 9809 case EM_68K:
3e0873ac 9810 return reloc_type == 4; /* R_68K_PC32. */
aca88567
NC		 9811 case EM_ALPHA:
9812 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9813 case EM_ARM:
3e0873ac 9814 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9815 case EM_MICROBLAZE:
9816 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9817 case EM_PARISC:
85acf597 9818 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9819 case EM_PPC:
9820 return reloc_type == 26; /* R_PPC_REL32. */
9821 case EM_PPC64:
3e0873ac 9822 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9823 case EM_S390_OLD:
9824 case EM_S390:
3e0873ac 9825 return reloc_type == 5; /* R_390_PC32. */
aca88567 9826 case EM_SH:
3e0873ac 9827 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9828 case EM_SPARC32PLUS:
9829 case EM_SPARCV9:
9830 case EM_SPARC:
3e0873ac 9831 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9832 case EM_SPU:
9833 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9834 case EM_TILEGX:
9835 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9836 case EM_TILEPRO:
9837 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 9838 case EM_X86_64:
8a9036a4 9839 case EM_L1OM:
7a9068fe 9840 case EM_K1OM:
3e0873ac 9841 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 9842 case EM_XTENSA_OLD:
9843 case EM_XTENSA:
9844 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 9845 default:
9846 /* Do not abort or issue an error message here. Not all targets use
9847 pc-relative 32-bit relocs in their DWARF debug information and we
9848 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 9849 more helpful warning message will be generated by apply_relocations
9850 anyway, so just return. */
aca88567
NC		 9851 return FALSE;
9852 }
9853}
9854
9855/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9856 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9857
9858static bfd_boolean
9859is_64bit_abs_reloc (unsigned int reloc_type)
9860{
9861 switch (elf_header.e_machine)
9862 {
9863 case EM_ALPHA:
9864 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 9865 case EM_IA_64:
9866 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 9867 case EM_PARISC:
9868 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 9869 case EM_PPC64:
9870 return reloc_type == 38; /* R_PPC64_ADDR64. */
9871 case EM_SPARC32PLUS:
9872 case EM_SPARCV9:
9873 case EM_SPARC:
9874 return reloc_type == 54; /* R_SPARC_UA64. */
9875 case EM_X86_64:
8a9036a4 9876 case EM_L1OM:
7a9068fe 9877 case EM_K1OM:
aca88567 9878 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 9879 case EM_S390_OLD:
9880 case EM_S390:
aa137e4d
NC		 9881 return reloc_type == 22; /* R_S390_64. */
9882 case EM_TILEGX:
9883 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 9884 case EM_MIPS:
aa137e4d 9885 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 9886 default:
9887 return FALSE;
9888 }
9889}
9890
85acf597
RH		 9891/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9892 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9893
9894static bfd_boolean
9895is_64bit_pcrel_reloc (unsigned int reloc_type)
9896{
9897 switch (elf_header.e_machine)
9898 {
9899 case EM_ALPHA:
aa137e4d 9900 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 9901 case EM_IA_64:
aa137e4d 9902 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 9903 case EM_PARISC:
aa137e4d 9904 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 9905 case EM_PPC64:
aa137e4d 9906 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 9907 case EM_SPARC32PLUS:
9908 case EM_SPARCV9:
9909 case EM_SPARC:
aa137e4d 9910 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 9911 case EM_X86_64:
8a9036a4 9912 case EM_L1OM:
7a9068fe 9913 case EM_K1OM:
aa137e4d 9914 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 9915 case EM_S390_OLD:
9916 case EM_S390:
aa137e4d
NC		 9917 return reloc_type == 23; /* R_S390_PC64. */
9918 case EM_TILEGX:
9919 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 9920 default:
9921 return FALSE;
9922 }
9923}
9924
4dc3c23d
AM		 9925/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9926 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9927
9928static bfd_boolean
9929is_24bit_abs_reloc (unsigned int reloc_type)
9930{
9931 switch (elf_header.e_machine)
9932 {
9933 case EM_CYGNUS_MN10200:
9934 case EM_MN10200:
9935 return reloc_type == 4; /* R_MN10200_24. */
9936 default:
9937 return FALSE;
9938 }
9939}
9940
aca88567
NC		 9941/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9942 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9943
9944static bfd_boolean
9945is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 9946{
9947 switch (elf_header.e_machine)
9948 {
aca88567
NC		 9949 case EM_AVR_OLD:
9950 case EM_AVR:
9951 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 9952 case EM_CYGNUS_D10V:
9953 case EM_D10V:
9954 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 9955 case EM_H8S:
9956 case EM_H8_300:
9957 case EM_H8_300H:
aca88567
NC		 9958 return reloc_type == R_H8_DIR16;
9959 case EM_IP2K_OLD:
9960 case EM_IP2K:
9961 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 9962 case EM_M32C_OLD:
f4236fe4
DD		 9963 case EM_M32C:
9964 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 9965 case EM_MSP430_OLD:
9966 case EM_MSP430:
9967 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 9968 case EM_ALTERA_NIOS2:
9969 case EM_NIOS32:
9970 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 9971 case EM_TI_C6000:
9972 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 9973 case EM_XC16X:
9974 case EM_C166:
9975 return reloc_type == 2; /* R_XC16C_ABS_16. */
4b78141a 9976 default:
aca88567 9977 return FALSE;
4b78141a
NC		 9978 }
9979}
9980
2a7b2e88
JK		 9981/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9982 relocation entries (possibly formerly used for SHT_GROUP sections). */
9983
9984static bfd_boolean
9985is_none_reloc (unsigned int reloc_type)
9986{
9987 switch (elf_header.e_machine)
9988 {
cb8f3167
NC		 9989 case EM_68K: /* R_68K_NONE. */
9990 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 9991 case EM_SPARC32PLUS:
9992 case EM_SPARCV9:
cb8f3167
NC		 9993 case EM_SPARC: /* R_SPARC_NONE. */
9994 case EM_MIPS: /* R_MIPS_NONE. */
9995 case EM_PARISC: /* R_PARISC_NONE. */
9996 case EM_ALPHA: /* R_ALPHA_NONE. */
9997 case EM_PPC: /* R_PPC_NONE. */
9998 case EM_PPC64: /* R_PPC64_NONE. */
9999 case EM_ARM: /* R_ARM_NONE. */
10000 case EM_IA_64: /* R_IA64_NONE. */
10001 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10002 case EM_S390_OLD:
cb8f3167
NC		 10003 case EM_S390: /* R_390_NONE. */
10004 case EM_CRIS: /* R_CRIS_NONE. */
10005 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10006 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10007 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10008 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10009 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10010 case EM_M32R: /* R_M32R_NONE. */
40b36596 10011 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10012 case EM_TILEGX: /* R_TILEGX_NONE. */
10013 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10014 case EM_XC16X:
10015 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10016 return reloc_type == 0;
58332dda
JK		 10017 case EM_XTENSA_OLD:
10018 case EM_XTENSA:
4dc3c23d
AM		 10019 return (reloc_type == 0 /* R_XTENSA_NONE. */
10020 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10021 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10022 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10023 }
10024 return FALSE;
10025}
10026
cf13d699
NC		 10027/* Apply relocations to a section.
10028 Note: So far support has been added only for those relocations
10029 which can be found in debug sections.
10030 FIXME: Add support for more relocations ? */
1b315056 10031
cf13d699
NC		 10032static void
10033apply_relocations (void * file,
10034 Elf_Internal_Shdr * section,
10035 unsigned char * start)
1b315056 10036{
cf13d699
NC		 10037 Elf_Internal_Shdr * relsec;
10038 unsigned char * end = start + section->sh_size;
cb8f3167 10039
cf13d699
NC		 10040 if (elf_header.e_type != ET_REL)
10041 return;
1b315056 10042
cf13d699 10043 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10044 for (relsec = section_headers;
10045 relsec < section_headers + elf_header.e_shnum;
10046 ++relsec)
252b5132 10047 {
41e92641
NC		 10048 bfd_boolean is_rela;
10049 unsigned long num_relocs;
2cf0635d
NC		 10050 Elf_Internal_Rela * relocs;
10051 Elf_Internal_Rela * rp;
10052 Elf_Internal_Shdr * symsec;
10053 Elf_Internal_Sym * symtab;
10054 Elf_Internal_Sym * sym;
252b5132 10055
41e92641 10056 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10057 || relsec->sh_info >= elf_header.e_shnum
10058 || section_headers + relsec->sh_info != section
c256ffe7 10059 || relsec->sh_size == 0
4fbb74a6 10060 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10061 continue;
428409d5 10062
41e92641
NC		 10063 is_rela = relsec->sh_type == SHT_RELA;
10064
10065 if (is_rela)
10066 {
3f5e193b
NC		 10067 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10068 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10069 return;
10070 }
10071 else
10072 {
3f5e193b
NC		 10073 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10074 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10075 return;
10076 }
10077
10078 /* SH uses RELA but uses in place value instead of the addend field. */
10079 if (elf_header.e_machine == EM_SH)
10080 is_rela = FALSE;
428409d5 10081
4fbb74a6 10082 symsec = section_headers + relsec->sh_link;
3f5e193b 10083 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
103f02d3 10084
41e92641 10085 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10086 {
41e92641
NC		 10087 bfd_vma addend;
10088 unsigned int reloc_type;
10089 unsigned int reloc_size;
91d6fa6a 10090 unsigned char * rloc;
4b78141a 10091
aca88567 10092 reloc_type = get_reloc_type (rp->r_info);
41e92641 10093
98fb390a 10094 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10095 continue;
98fb390a
NC		 10096 else if (is_none_reloc (reloc_type))
10097 continue;
10098 else if (is_32bit_abs_reloc (reloc_type)
10099 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10100 reloc_size = 4;
85acf597
RH		 10101 else if (is_64bit_abs_reloc (reloc_type)
10102 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10103 reloc_size = 8;
4dc3c23d
AM		 10104 else if (is_24bit_abs_reloc (reloc_type))
10105 reloc_size = 3;
aca88567
NC		 10106 else if (is_16bit_abs_reloc (reloc_type))
10107 reloc_size = 2;
10108 else
4b78141a 10109 {
41e92641 10110 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10111 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10112 continue;
10113 }
103f02d3 10114
91d6fa6a
NC		 10115 rloc = start + rp->r_offset;
10116 if ((rloc + reloc_size) > end)
700dd8b7
L		 10117 {
10118 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10119 (unsigned long) rp->r_offset,
10120 SECTION_NAME (section));
10121 continue;
10122 }
103f02d3 10123
41e92641
NC		 10124 sym = symtab + get_reloc_symindex (rp->r_info);
10125
10126 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10127 make sure that it is of an appropriate type.
10128
10129 Relocations against symbols without type can happen.
10130 Gcc -feliminate-dwarf2-dups may generate symbols
10131 without type for debug info.
10132
10133 Icc generates relocations against function symbols
10134 instead of local labels.
10135
10136 Relocations against object symbols can happen, eg when
10137 referencing a global array. For an example of this see
10138 the _clz.o binary in libgcc.a. */
aca88567 10139 if (sym != symtab
55f25fc3 10140 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10141 {
41e92641 10142 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10143 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10144 (long int)(rp - relocs),
41e92641 10145 SECTION_NAME (relsec));
aca88567 10146 continue;
5b18a4bc 10147 }
252b5132 10148
4dc3c23d
AM		 10149 addend = 0;
10150 if (is_rela)
10151 addend += rp->r_addend;
c47320c3
AM		 10152 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10153 partial_inplace. */
4dc3c23d
AM		 10154 if (!is_rela
10155 || (elf_header.e_machine == EM_XTENSA
10156 && reloc_type == 1)
10157 || ((elf_header.e_machine == EM_PJ
10158 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10159 && reloc_type == 1)
10160 || ((elf_header.e_machine == EM_D30V
10161 || elf_header.e_machine == EM_CYGNUS_D30V)
10162 && reloc_type == 12))
91d6fa6a 10163 addend += byte_get (rloc, reloc_size);
cb8f3167 10164
85acf597
RH		 10165 if (is_32bit_pcrel_reloc (reloc_type)
10166 || is_64bit_pcrel_reloc (reloc_type))
10167 {
10168 /* On HPPA, all pc-relative relocations are biased by 8. */
10169 if (elf_header.e_machine == EM_PARISC)
10170 addend -= 8;
91d6fa6a 10171 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10172 reloc_size);
10173 }
41e92641 10174 else
91d6fa6a 10175 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10176 }
252b5132 10177
5b18a4bc 10178 free (symtab);
41e92641 10179 free (relocs);
5b18a4bc
NC		 10180 break;
10181 }
5b18a4bc 10182}
103f02d3 10183
cf13d699
NC		 10184#ifdef SUPPORT_DISASSEMBLY
10185static int
10186disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10187{
10188 printf (_("\nAssembly dump of section %s\n"),
10189 SECTION_NAME (section));
10190
10191 /* XXX -- to be done --- XXX */
10192
10193 return 1;
10194}
10195#endif
10196
10197/* Reads in the contents of SECTION from FILE, returning a pointer
10198 to a malloc'ed buffer or NULL if something went wrong. */
10199
10200static char *
10201get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10202{
10203 bfd_size_type num_bytes;
10204
10205 num_bytes = section->sh_size;
10206
10207 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10208 {
10209 printf (_("\nSection '%s' has no data to dump.\n"),
10210 SECTION_NAME (section));
10211 return NULL;
10212 }
10213
3f5e193b
NC		 10214 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10215 _("section contents"));
cf13d699
NC		 10216}
10217
dd24e3da 10218
cf13d699
NC		 10219static void
10220dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10221{
10222 Elf_Internal_Shdr * relsec;
10223 bfd_size_type num_bytes;
cf13d699
NC		 10224 char * data;
10225 char * end;
10226 char * start;
10227 char * name = SECTION_NAME (section);
10228 bfd_boolean some_strings_shown;
10229
10230 start = get_section_contents (section, file);
10231 if (start == NULL)
10232 return;
10233
10234 printf (_("\nString dump of section '%s':\n"), name);
10235
10236 /* If the section being dumped has relocations against it the user might
10237 be expecting these relocations to have been applied. Check for this
10238 case and issue a warning message in order to avoid confusion.
10239 FIXME: Maybe we ought to have an option that dumps a section with
10240 relocs applied ? */
10241 for (relsec = section_headers;
10242 relsec < section_headers + elf_header.e_shnum;
10243 ++relsec)
10244 {
10245 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10246 || relsec->sh_info >= elf_header.e_shnum
10247 || section_headers + relsec->sh_info != section
10248 || relsec->sh_size == 0
10249 || relsec->sh_link >= elf_header.e_shnum)
10250 continue;
10251
10252 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10253 break;
10254 }
10255
10256 num_bytes = section->sh_size;
cf13d699
NC		 10257 data = start;
10258 end = start + num_bytes;
10259 some_strings_shown = FALSE;
10260
10261 while (data < end)
10262 {
10263 while (!ISPRINT (* data))
10264 if (++ data >= end)
10265 break;
10266
10267 if (data < end)
10268 {
10269#ifndef __MSVCRT__
c975cc98
NC		 10270 /* PR 11128: Use two separate invocations in order to work
10271 around bugs in the Solaris 8 implementation of printf. */
10272 printf (" [%6tx] ", data - start);
10273 printf ("%s\n", data);
cf13d699
NC		 10274#else
10275 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10276#endif
10277 data += strlen (data);
10278 some_strings_shown = TRUE;
10279 }
10280 }
10281
10282 if (! some_strings_shown)
10283 printf (_(" No strings found in this section."));
10284
10285 free (start);
10286
10287 putchar ('\n');
10288}
10289
10290static void
10291dump_section_as_bytes (Elf_Internal_Shdr * section,
10292 FILE * file,
10293 bfd_boolean relocate)
10294{
10295 Elf_Internal_Shdr * relsec;
10296 bfd_size_type bytes;
10297 bfd_vma addr;
10298 unsigned char * data;
10299 unsigned char * start;
10300
10301 start = (unsigned char *) get_section_contents (section, file);
10302 if (start == NULL)
10303 return;
10304
10305 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10306
10307 if (relocate)
10308 {
10309 apply_relocations (file, section, start);
10310 }
10311 else
10312 {
10313 /* If the section being dumped has relocations against it the user might
10314 be expecting these relocations to have been applied. Check for this
10315 case and issue a warning message in order to avoid confusion.
10316 FIXME: Maybe we ought to have an option that dumps a section with
10317 relocs applied ? */
10318 for (relsec = section_headers;
10319 relsec < section_headers + elf_header.e_shnum;
10320 ++relsec)
10321 {
10322 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10323 || relsec->sh_info >= elf_header.e_shnum
10324 || section_headers + relsec->sh_info != section
10325 || relsec->sh_size == 0
10326 || relsec->sh_link >= elf_header.e_shnum)
10327 continue;
10328
10329 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10330 break;
10331 }
10332 }
10333
10334 addr = section->sh_addr;
10335 bytes = section->sh_size;
10336 data = start;
10337
10338 while (bytes)
10339 {
10340 int j;
10341 int k;
10342 int lbytes;
10343
10344 lbytes = (bytes > 16 ? 16 : bytes);
10345
10346 printf (" 0x%8.8lx ", (unsigned long) addr);
10347
10348 for (j = 0; j < 16; j++)
10349 {
10350 if (j < lbytes)
10351 printf ("%2.2x", data[j]);
10352 else
10353 printf (" ");
10354
10355 if ((j & 3) == 3)
10356 printf (" ");
10357 }
10358
10359 for (j = 0; j < lbytes; j++)
10360 {
10361 k = data[j];
10362 if (k >= ' ' && k < 0x7f)
10363 printf ("%c", k);
10364 else
10365 printf (".");
10366 }
10367
10368 putchar ('\n');
10369
10370 data += lbytes;
10371 addr += lbytes;
10372 bytes -= lbytes;
10373 }
10374
10375 free (start);
10376
10377 putchar ('\n');
10378}
10379
4a114e3e 10380/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10381
10382static int
d3dbc530
AM		 10383uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10384 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10385{
10386#ifndef HAVE_ZLIB_H
cf13d699
NC		 10387 return FALSE;
10388#else
10389 dwarf_size_type compressed_size = *size;
10390 unsigned char * compressed_buffer = *buffer;
10391 dwarf_size_type uncompressed_size;
10392 unsigned char * uncompressed_buffer;
10393 z_stream strm;
10394 int rc;
10395 dwarf_size_type header_size = 12;
10396
10397 /* Read the zlib header. In this case, it should be "ZLIB" followed
10398 by the uncompressed section size, 8 bytes in big-endian order. */
10399 if (compressed_size < header_size
10400 || ! streq ((char *) compressed_buffer, "ZLIB"))
10401 return 0;
10402
10403 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10404 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10405 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10406 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10407 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10408 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10409 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10410 uncompressed_size += compressed_buffer[11];
10411
10412 /* It is possible the section consists of several compressed
10413 buffers concatenated together, so we uncompress in a loop. */
10414 strm.zalloc = NULL;
10415 strm.zfree = NULL;
10416 strm.opaque = NULL;
10417 strm.avail_in = compressed_size - header_size;
10418 strm.next_in = (Bytef *) compressed_buffer + header_size;
10419 strm.avail_out = uncompressed_size;
3f5e193b 10420 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10421
10422 rc = inflateInit (& strm);
10423 while (strm.avail_in > 0)
10424 {
10425 if (rc != Z_OK)
10426 goto fail;
10427 strm.next_out = ((Bytef *) uncompressed_buffer
10428 + (uncompressed_size - strm.avail_out));
10429 rc = inflate (&strm, Z_FINISH);
10430 if (rc != Z_STREAM_END)
10431 goto fail;
10432 rc = inflateReset (& strm);
10433 }
10434 rc = inflateEnd (& strm);
10435 if (rc != Z_OK
10436 || strm.avail_out != 0)
10437 goto fail;
10438
10439 free (compressed_buffer);
10440 *buffer = uncompressed_buffer;
10441 *size = uncompressed_size;
10442 return 1;
10443
10444 fail:
10445 free (uncompressed_buffer);
4a114e3e
L		 10446 /* Indicate decompression failure. */
10447 *buffer = NULL;
cf13d699
NC		 10448 return 0;
10449#endif /* HAVE_ZLIB_H */
10450}
10451
d966045b
DJ		 10452static int
10453load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10454 Elf_Internal_Shdr * sec, void * file)
1007acb3 10455{
2cf0635d 10456 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10457 char buf [64];
1007acb3 10458
19e6b90e
L		 10459 /* If it is already loaded, do nothing. */
10460 if (section->start != NULL)
10461 return 1;
1007acb3 10462
19e6b90e
L		 10463 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10464 section->address = sec->sh_addr;
3f5e193b
NC		 10465 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10466 sec->sh_offset, 1,
10467 sec->sh_size, buf);
59245841
NC		 10468 if (section->start == NULL)
10469 section->size = 0;
10470 else
10471 {
10472 section->size = sec->sh_size;
10473 if (uncompress_section_contents (&section->start, &section->size))
10474 sec->sh_size = section->size;
10475 }
4a114e3e 10476
1b315056
CS		 10477 if (section->start == NULL)
10478 return 0;
10479
19e6b90e 10480 if (debug_displays [debug].relocate)
3f5e193b 10481 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10482
1b315056 10483 return 1;
1007acb3
L		 10484}
10485
d966045b 10486int
2cf0635d 10487load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10488{
2cf0635d
NC		 10489 struct dwarf_section * section = &debug_displays [debug].section;
10490 Elf_Internal_Shdr * sec;
d966045b
DJ		 10491
10492 /* Locate the debug section. */
10493 sec = find_section (section->uncompressed_name);
10494 if (sec != NULL)
10495 section->name = section->uncompressed_name;
10496 else
10497 {
10498 sec = find_section (section->compressed_name);
10499 if (sec != NULL)
10500 section->name = section->compressed_name;
10501 }
10502 if (sec == NULL)
10503 return 0;
10504
3f5e193b 10505 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10506}
10507
19e6b90e
L		 10508void
10509free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10510{
2cf0635d 10511 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10512
19e6b90e
L		 10513 if (section->start == NULL)
10514 return;
1007acb3 10515
19e6b90e
L		 10516 free ((char *) section->start);
10517 section->start = NULL;
10518 section->address = 0;
10519 section->size = 0;
1007acb3
L		 10520}
10521
1007acb3 10522static int
2cf0635d 10523display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10524{
2cf0635d 10525 char * name = SECTION_NAME (section);
19e6b90e
L		 10526 bfd_size_type length;
10527 int result = 1;
3f5e193b 10528 int i;
1007acb3 10529
19e6b90e
L		 10530 length = section->sh_size;
10531 if (length == 0)
1007acb3 10532 {
19e6b90e
L		 10533 printf (_("\nSection '%s' has no debugging data.\n"), name);
10534 return 0;
1007acb3 10535 }
5dff79d8
NC		 10536 if (section->sh_type == SHT_NOBITS)
10537 {
10538 /* There is no point in dumping the contents of a debugging section
10539 which has the NOBITS type - the bits in the file will be random.
10540 This can happen when a file containing a .eh_frame section is
10541 stripped with the --only-keep-debug command line option. */
10542 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10543 return 0;
10544 }
1007acb3 10545
0112cd26 10546 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10547 name = ".debug_info";
1007acb3 10548
19e6b90e
L		 10549 /* See if we know how to display the contents of this section. */
10550 for (i = 0; i < max; i++)
1b315056
CS		 10551 if (streq (debug_displays[i].section.uncompressed_name, name)
10552 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10553 {
2cf0635d 10554 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10555 int secondary = (section != find_section (name));
10556
10557 if (secondary)
3f5e193b 10558 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10559
2b6f5997 10560 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10561 sec->name = sec->uncompressed_name;
10562 else
10563 sec->name = sec->compressed_name;
3f5e193b
NC		 10564 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10565 section, file))
19e6b90e
L		 10566 {
10567 result &= debug_displays[i].display (sec, file);
1007acb3 10568
d966045b 10569 if (secondary || (i != info && i != abbrev))
3f5e193b 10570 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10571 }
1007acb3 10572
19e6b90e
L		 10573 break;
10574 }
1007acb3 10575
19e6b90e 10576 if (i == max)
1007acb3 10577 {
19e6b90e
L		 10578 printf (_("Unrecognized debug section: %s\n"), name);
10579 result = 0;
1007acb3
L		 10580 }
10581
19e6b90e 10582 return result;
5b18a4bc 10583}
103f02d3 10584
aef1f6d0
DJ		 10585/* Set DUMP_SECTS for all sections where dumps were requested
10586 based on section name. */
10587
10588static void
10589initialise_dumps_byname (void)
10590{
2cf0635d 10591 struct dump_list_entry * cur;
aef1f6d0
DJ		 10592
10593 for (cur = dump_sects_byname; cur; cur = cur->next)
10594 {
10595 unsigned int i;
10596 int any;
10597
10598 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10599 if (streq (SECTION_NAME (section_headers + i), cur->name))
10600 {
09c11c86 10601 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10602 any = 1;
10603 }
10604
10605 if (!any)
10606 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10607 cur->name);
10608 }
10609}
10610
5b18a4bc 10611static void
2cf0635d 10612process_section_contents (FILE * file)
5b18a4bc 10613{
2cf0635d 10614 Elf_Internal_Shdr * section;
19e6b90e 10615 unsigned int i;
103f02d3 10616
19e6b90e
L		 10617 if (! do_dump)
10618 return;
103f02d3 10619
aef1f6d0
DJ		 10620 initialise_dumps_byname ();
10621
19e6b90e
L		 10622 for (i = 0, section = section_headers;
10623 i < elf_header.e_shnum && i < num_dump_sects;
10624 i++, section++)
10625 {
10626#ifdef SUPPORT_DISASSEMBLY
10627 if (dump_sects[i] & DISASS_DUMP)
10628 disassemble_section (section, file);
10629#endif
10630 if (dump_sects[i] & HEX_DUMP)
cf13d699 10631 dump_section_as_bytes (section, file, FALSE);
103f02d3 10632
cf13d699
NC		 10633 if (dump_sects[i] & RELOC_DUMP)
10634 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10635
10636 if (dump_sects[i] & STRING_DUMP)
10637 dump_section_as_strings (section, file);
cf13d699
NC		 10638
10639 if (dump_sects[i] & DEBUG_DUMP)
10640 display_debug_section (section, file);
5b18a4bc 10641 }
103f02d3 10642
19e6b90e
L		 10643 /* Check to see if the user requested a
10644 dump of a section that does not exist. */
10645 while (i++ < num_dump_sects)
10646 if (dump_sects[i])
10647 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10648}
103f02d3 10649
5b18a4bc 10650static void
19e6b90e 10651process_mips_fpe_exception (int mask)
5b18a4bc 10652{
19e6b90e
L		 10653 if (mask)
10654 {
10655 int first = 1;
10656 if (mask & OEX_FPU_INEX)
10657 fputs ("INEX", stdout), first = 0;
10658 if (mask & OEX_FPU_UFLO)
10659 printf ("%sUFLO", first ? "" : "|"), first = 0;
10660 if (mask & OEX_FPU_OFLO)
10661 printf ("%sOFLO", first ? "" : "|"), first = 0;
10662 if (mask & OEX_FPU_DIV0)
10663 printf ("%sDIV0", first ? "" : "|"), first = 0;
10664 if (mask & OEX_FPU_INVAL)
10665 printf ("%sINVAL", first ? "" : "|");
10666 }
5b18a4bc 10667 else
19e6b90e 10668 fputs ("0", stdout);
5b18a4bc 10669}
103f02d3 10670
11c1ff18
PB		 10671/* ARM EABI attributes section. */
10672typedef struct
10673{
10674 int tag;
2cf0635d 10675 const char * name;
11c1ff18
PB		 10676 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10677 int type;
2cf0635d 10678 const char ** table;
11c1ff18
PB		 10679} arm_attr_public_tag;
10680
2cf0635d 10681static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10682 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9e3c6df6 10683 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
2cf0635d
NC		 10684static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10685static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10686 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10687static const char * arm_attr_tag_FP_arch[] =
62f3b8c8 10688 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
2cf0635d 10689static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10690static const char * arm_attr_tag_Advanced_SIMD_arch[] =
cd21e546 10691 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
2cf0635d 10692static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10693 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10694 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10695static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10696 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10697static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10698 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10699static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10700 {"Absolute", "PC-relative", "None"};
2cf0635d 10701static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10702 {"None", "direct", "GOT-indirect"};
2cf0635d 10703static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10704 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10705static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10706static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10707 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10708static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10709static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10710static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10711 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10712static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10713 {"Unused", "small", "int", "forced to int"};
2cf0635d 10714static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10715 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10716static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10717 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10718static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10719 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10720static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10721 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10722 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10723static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10724 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10725 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10726static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10727static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10728 {"Not Allowed", "Allowed"};
2cf0635d 10729static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10730 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10731static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10732 {"Not Allowed", "Allowed"};
10733static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10734 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10735 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10736static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10737static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10738 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10739 "TrustZone and Virtualization Extensions"};
dd24e3da 10740static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10741 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10742
10743#define LOOKUP(id, name) \
10744 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10745static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10746{
10747 {4, "CPU_raw_name", 1, NULL},
10748 {5, "CPU_name", 1, NULL},
10749 LOOKUP(6, CPU_arch),
10750 {7, "CPU_arch_profile", 0, NULL},
10751 LOOKUP(8, ARM_ISA_use),
10752 LOOKUP(9, THUMB_ISA_use),
75375b3e 10753 LOOKUP(10, FP_arch),
11c1ff18 10754 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10755 LOOKUP(12, Advanced_SIMD_arch),
10756 LOOKUP(13, PCS_config),
11c1ff18
PB		 10757 LOOKUP(14, ABI_PCS_R9_use),
10758 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10759 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10760 LOOKUP(17, ABI_PCS_GOT_use),
10761 LOOKUP(18, ABI_PCS_wchar_t),
10762 LOOKUP(19, ABI_FP_rounding),
10763 LOOKUP(20, ABI_FP_denormal),
10764 LOOKUP(21, ABI_FP_exceptions),
10765 LOOKUP(22, ABI_FP_user_exceptions),
10766 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10767 {24, "ABI_align_needed", 0, NULL},
10768 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10769 LOOKUP(26, ABI_enum_size),
10770 LOOKUP(27, ABI_HardFP_use),
10771 LOOKUP(28, ABI_VFP_args),
10772 LOOKUP(29, ABI_WMMX_args),
10773 LOOKUP(30, ABI_optimization_goals),
10774 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10775 {32, "compatibility", 0, NULL},
f5f53991 10776 LOOKUP(34, CPU_unaligned_access),
75375b3e 10777 LOOKUP(36, FP_HP_extension),
8e79c3df 10778 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10779 LOOKUP(42, MPextension_use),
10780 LOOKUP(44, DIV_use),
f5f53991
AS		 10781 {64, "nodefaults", 0, NULL},
10782 {65, "also_compatible_with", 0, NULL},
10783 LOOKUP(66, T2EE_use),
10784 {67, "conformance", 1, NULL},
10785 LOOKUP(68, Virtualization_use),
cd21e546 10786 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10787};
10788#undef LOOKUP
10789
11c1ff18 10790static unsigned char *
2cf0635d 10791display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10792{
10793 int tag;
10794 unsigned int len;
10795 int val;
2cf0635d 10796 arm_attr_public_tag * attr;
11c1ff18
PB		 10797 unsigned i;
10798 int type;
10799
10800 tag = read_uleb128 (p, &len);
10801 p += len;
10802 attr = NULL;
2cf0635d 10803 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10804 {
10805 if (arm_attr_public_tags[i].tag == tag)
10806 {
10807 attr = &arm_attr_public_tags[i];
10808 break;
10809 }
10810 }
10811
10812 if (attr)
10813 {
10814 printf (" Tag_%s: ", attr->name);
10815 switch (attr->type)
10816 {
10817 case 0:
10818 switch (tag)
10819 {
10820 case 7: /* Tag_CPU_arch_profile. */
10821 val = read_uleb128 (p, &len);
10822 p += len;
10823 switch (val)
10824 {
2b692964
NC		 10825 case 0: printf (_("None\n")); break;
10826 case 'A': printf (_("Application\n")); break;
10827 case 'R': printf (_("Realtime\n")); break;
10828 case 'M': printf (_("Microcontroller\n")); break;
10829 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 10830 default: printf ("??? (%d)\n", val); break;
10831 }
10832 break;
10833
75375b3e
MGD		 10834 case 24: /* Tag_align_needed. */
10835 val = read_uleb128 (p, &len);
10836 p += len;
10837 switch (val)
10838 {
2b692964
NC		 10839 case 0: printf (_("None\n")); break;
10840 case 1: printf (_("8-byte\n")); break;
10841 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 10842 case 3: printf ("??? 3\n"); break;
10843 default:
10844 if (val <= 12)
dd24e3da 10845 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10846 1 << val);
10847 else
10848 printf ("??? (%d)\n", val);
10849 break;
10850 }
10851 break;
10852
10853 case 25: /* Tag_align_preserved. */
10854 val = read_uleb128 (p, &len);
10855 p += len;
10856 switch (val)
10857 {
2b692964
NC		 10858 case 0: printf (_("None\n")); break;
10859 case 1: printf (_("8-byte, except leaf SP\n")); break;
10860 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 10861 case 3: printf ("??? 3\n"); break;
10862 default:
10863 if (val <= 12)
dd24e3da 10864 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 10865 1 << val);
10866 else
10867 printf ("??? (%d)\n", val);
10868 break;
10869 }
10870 break;
10871
11c1ff18
PB		 10872 case 32: /* Tag_compatibility. */
10873 val = read_uleb128 (p, &len);
10874 p += len;
2b692964 10875 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 10876 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10877 break;
10878
f5f53991
AS		 10879 case 64: /* Tag_nodefaults. */
10880 p++;
2b692964 10881 printf (_("True\n"));
f5f53991
AS		 10882 break;
10883
10884 case 65: /* Tag_also_compatible_with. */
10885 val = read_uleb128 (p, &len);
10886 p += len;
10887 if (val == 6 /* Tag_CPU_arch. */)
10888 {
10889 val = read_uleb128 (p, &len);
10890 p += len;
2cf0635d 10891 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 10892 printf ("??? (%d)\n", val);
10893 else
10894 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10895 }
10896 else
10897 printf ("???\n");
10898 while (*(p++) != '\0' /* NUL terminator. */);
10899 break;
10900
11c1ff18 10901 default:
2cf0635d 10902 abort ();
11c1ff18
PB		 10903 }
10904 return p;
10905
10906 case 1:
10907 case 2:
10908 type = attr->type;
10909 break;
10910
10911 default:
10912 assert (attr->type & 0x80);
10913 val = read_uleb128 (p, &len);
10914 p += len;
10915 type = attr->type & 0x7f;
10916 if (val >= type)
10917 printf ("??? (%d)\n", val);
10918 else
10919 printf ("%s\n", attr->table[val]);
10920 return p;
10921 }
10922 }
10923 else
10924 {
10925 if (tag & 1)
10926 type = 1; /* String. */
10927 else
10928 type = 2; /* uleb128. */
10929 printf (" Tag_unknown_%d: ", tag);
10930 }
10931
10932 if (type == 1)
10933 {
10934 printf ("\"%s\"\n", p);
2cf0635d 10935 p += strlen ((char *) p) + 1;
11c1ff18
PB		 10936 }
10937 else
10938 {
10939 val = read_uleb128 (p, &len);
10940 p += len;
10941 printf ("%d (0x%x)\n", val, val);
10942 }
10943
10944 return p;
10945}
10946
104d59d1 10947static unsigned char *
60bca95a
NC		 10948display_gnu_attribute (unsigned char * p,
10949 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 10950{
10951 int tag;
10952 unsigned int len;
10953 int val;
10954 int type;
10955
10956 tag = read_uleb128 (p, &len);
10957 p += len;
10958
10959 /* Tag_compatibility is the only generic GNU attribute defined at
10960 present. */
10961 if (tag == 32)
10962 {
10963 val = read_uleb128 (p, &len);
10964 p += len;
2b692964 10965 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 10966 p += strlen ((char *) p) + 1;
104d59d1
JM		 10967 return p;
10968 }
10969
10970 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10971 return display_proc_gnu_attribute (p, tag);
10972
10973 if (tag & 1)
10974 type = 1; /* String. */
10975 else
10976 type = 2; /* uleb128. */
10977 printf (" Tag_unknown_%d: ", tag);
10978
10979 if (type == 1)
10980 {
10981 printf ("\"%s\"\n", p);
60bca95a 10982 p += strlen ((char *) p) + 1;
104d59d1
JM		 10983 }
10984 else
10985 {
10986 val = read_uleb128 (p, &len);
10987 p += len;
10988 printf ("%d (0x%x)\n", val, val);
10989 }
10990
10991 return p;
10992}
10993
34c8bcba 10994static unsigned char *
2cf0635d 10995display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 10996{
10997 int type;
10998 unsigned int len;
10999 int val;
11000
11001 if (tag == Tag_GNU_Power_ABI_FP)
11002 {
11003 val = read_uleb128 (p, &len);
11004 p += len;
11005 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11006
34c8bcba
JM		 11007 switch (val)
11008 {
11009 case 0:
2b692964 11010 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11011 break;
11012 case 1:
2b692964 11013 printf (_("Hard float\n"));
34c8bcba
JM		 11014 break;
11015 case 2:
2b692964 11016 printf (_("Soft float\n"));
34c8bcba 11017 break;
3c7b9897 11018 case 3:
2b692964 11019 printf (_("Single-precision hard float\n"));
3c7b9897 11020 break;
34c8bcba
JM		 11021 default:
11022 printf ("??? (%d)\n", val);
11023 break;
11024 }
11025 return p;
11026 }
11027
c6e65352
DJ		 11028 if (tag == Tag_GNU_Power_ABI_Vector)
11029 {
11030 val = read_uleb128 (p, &len);
11031 p += len;
11032 printf (" Tag_GNU_Power_ABI_Vector: ");
11033 switch (val)
11034 {
11035 case 0:
2b692964 11036 printf (_("Any\n"));
c6e65352
DJ		 11037 break;
11038 case 1:
2b692964 11039 printf (_("Generic\n"));
c6e65352
DJ		 11040 break;
11041 case 2:
11042 printf ("AltiVec\n");
11043 break;
11044 case 3:
11045 printf ("SPE\n");
11046 break;
11047 default:
11048 printf ("??? (%d)\n", val);
11049 break;
11050 }
11051 return p;
11052 }
11053
f82e0623
NF		 11054 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11055 {
11056 val = read_uleb128 (p, &len);
11057 p += len;
11058 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11059 switch (val)
11060 {
11061 case 0:
2b692964 11062 printf (_("Any\n"));
f82e0623
NF		 11063 break;
11064 case 1:
11065 printf ("r3/r4\n");
11066 break;
11067 case 2:
2b692964 11068 printf (_("Memory\n"));
f82e0623
NF		 11069 break;
11070 default:
11071 printf ("??? (%d)\n", val);
11072 break;
11073 }
11074 return p;
11075 }
11076
34c8bcba
JM		 11077 if (tag & 1)
11078 type = 1; /* String. */
11079 else
11080 type = 2; /* uleb128. */
11081 printf (" Tag_unknown_%d: ", tag);
11082
11083 if (type == 1)
11084 {
11085 printf ("\"%s\"\n", p);
60bca95a 11086 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11087 }
11088 else
11089 {
11090 val = read_uleb128 (p, &len);
11091 p += len;
11092 printf ("%d (0x%x)\n", val, val);
11093 }
11094
11095 return p;
11096}
11097
2cf19d5c 11098static unsigned char *
2cf0635d 11099display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11100{
11101 int type;
11102 unsigned int len;
11103 int val;
11104
11105 if (tag == Tag_GNU_MIPS_ABI_FP)
11106 {
11107 val = read_uleb128 (p, &len);
11108 p += len;
11109 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11110
2cf19d5c
JM		 11111 switch (val)
11112 {
11113 case 0:
2b692964 11114 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11115 break;
11116 case 1:
2b692964 11117 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11118 break;
11119 case 2:
2b692964 11120 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11121 break;
11122 case 3:
2b692964 11123 printf (_("Soft float\n"));
2cf19d5c 11124 break;
42554f6a 11125 case 4:
9eeefea8 11126 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11127 break;
2cf19d5c
JM		 11128 default:
11129 printf ("??? (%d)\n", val);
11130 break;
11131 }
11132 return p;
11133 }
11134
11135 if (tag & 1)
11136 type = 1; /* String. */
11137 else
11138 type = 2; /* uleb128. */
11139 printf (" Tag_unknown_%d: ", tag);
11140
11141 if (type == 1)
11142 {
11143 printf ("\"%s\"\n", p);
60bca95a 11144 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11145 }
11146 else
11147 {
11148 val = read_uleb128 (p, &len);
11149 p += len;
11150 printf ("%d (0x%x)\n", val, val);
11151 }
11152
11153 return p;
11154}
11155
59e6276b
JM		 11156static unsigned char *
11157display_tic6x_attribute (unsigned char * p)
11158{
11159 int tag;
11160 unsigned int len;
11161 int val;
11162
11163 tag = read_uleb128 (p, &len);
11164 p += len;
11165
11166 switch (tag)
11167 {
75fa6dc1 11168 case Tag_ISA:
59e6276b
JM		 11169 val = read_uleb128 (p, &len);
11170 p += len;
75fa6dc1 11171 printf (" Tag_ISA: ");
59e6276b
JM		 11172
11173 switch (val)
11174 {
75fa6dc1 11175 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11176 printf (_("None\n"));
11177 break;
75fa6dc1 11178 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11179 printf ("C62x\n");
11180 break;
75fa6dc1 11181 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11182 printf ("C67x\n");
11183 break;
75fa6dc1 11184 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11185 printf ("C67x+\n");
11186 break;
75fa6dc1 11187 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11188 printf ("C64x\n");
11189 break;
75fa6dc1 11190 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11191 printf ("C64x+\n");
11192 break;
75fa6dc1 11193 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11194 printf ("C674x\n");
11195 break;
11196 default:
11197 printf ("??? (%d)\n", val);
11198 break;
11199 }
11200 return p;
11201
87779176
JM		 11202 case Tag_ABI_wchar_t:
11203 val = read_uleb128 (p, &len);
11204 p += len;
11205 printf (" Tag_ABI_wchar_t: ");
11206 switch (val)
11207 {
11208 case 0:
11209 printf (_("Not used\n"));
11210 break;
11211 case 1:
11212 printf (_("2 bytes\n"));
11213 break;
11214 case 2:
11215 printf (_("4 bytes\n"));
11216 break;
11217 default:
11218 printf ("??? (%d)\n", val);
11219 break;
11220 }
11221 return p;
11222
11223 case Tag_ABI_stack_align_needed:
11224 val = read_uleb128 (p, &len);
11225 p += len;
11226 printf (" Tag_ABI_stack_align_needed: ");
11227 switch (val)
11228 {
11229 case 0:
11230 printf (_("8-byte\n"));
11231 break;
11232 case 1:
11233 printf (_("16-byte\n"));
11234 break;
11235 default:
11236 printf ("??? (%d)\n", val);
11237 break;
11238 }
11239 return p;
11240
11241 case Tag_ABI_stack_align_preserved:
11242 val = read_uleb128 (p, &len);
11243 p += len;
11244 printf (" Tag_ABI_stack_align_preserved: ");
11245 switch (val)
11246 {
11247 case 0:
11248 printf (_("8-byte\n"));
11249 break;
11250 case 1:
11251 printf (_("16-byte\n"));
11252 break;
11253 default:
11254 printf ("??? (%d)\n", val);
11255 break;
11256 }
11257 return p;
11258
b5593623
JM		 11259 case Tag_ABI_DSBT:
11260 val = read_uleb128 (p, &len);
11261 p += len;
11262 printf (" Tag_ABI_DSBT: ");
11263 switch (val)
11264 {
11265 case 0:
11266 printf (_("DSBT addressing not used\n"));
11267 break;
11268 case 1:
11269 printf (_("DSBT addressing used\n"));
11270 break;
11271 default:
11272 printf ("??? (%d)\n", val);
11273 break;
11274 }
11275 return p;
11276
87779176
JM		 11277 case Tag_ABI_PID:
11278 val = read_uleb128 (p, &len);
11279 p += len;
11280 printf (" Tag_ABI_PID: ");
11281 switch (val)
11282 {
11283 case 0:
11284 printf (_("Data addressing position-dependent\n"));
11285 break;
11286 case 1:
11287 printf (_("Data addressing position-independent, GOT near DP\n"));
11288 break;
11289 case 2:
11290 printf (_("Data addressing position-independent, GOT far from DP\n"));
11291 break;
11292 default:
11293 printf ("??? (%d)\n", val);
11294 break;
11295 }
11296 return p;
11297
11298 case Tag_ABI_PIC:
11299 val = read_uleb128 (p, &len);
11300 p += len;
11301 printf (" Tag_ABI_PIC: ");
11302 switch (val)
11303 {
11304 case 0:
11305 printf (_("Code addressing position-dependent\n"));
11306 break;
11307 case 1:
11308 printf (_("Code addressing position-independent\n"));
11309 break;
11310 default:
11311 printf ("??? (%d)\n", val);
11312 break;
11313 }
11314 return p;
11315
11316 case Tag_ABI_array_object_alignment:
11317 val = read_uleb128 (p, &len);
11318 p += len;
11319 printf (" Tag_ABI_array_object_alignment: ");
11320 switch (val)
11321 {
11322 case 0:
11323 printf (_("8-byte\n"));
11324 break;
11325 case 1:
11326 printf (_("4-byte\n"));
11327 break;
11328 case 2:
11329 printf (_("16-byte\n"));
11330 break;
11331 default:
11332 printf ("??? (%d)\n", val);
11333 break;
11334 }
11335 return p;
11336
11337 case Tag_ABI_array_object_align_expected:
11338 val = read_uleb128 (p, &len);
11339 p += len;
11340 printf (" Tag_ABI_array_object_align_expected: ");
11341 switch (val)
11342 {
11343 case 0:
11344 printf (_("8-byte\n"));
11345 break;
11346 case 1:
11347 printf (_("4-byte\n"));
11348 break;
11349 case 2:
11350 printf (_("16-byte\n"));
11351 break;
11352 default:
11353 printf ("??? (%d)\n", val);
11354 break;
11355 }
11356 return p;
11357
3cbd1c06 11358 case Tag_ABI_compatibility:
59e6276b
JM		 11359 val = read_uleb128 (p, &len);
11360 p += len;
3cbd1c06 11361 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11362 printf (_("flag = %d, vendor = %s\n"), val, p);
11363 p += strlen ((char *) p) + 1;
11364 return p;
87779176
JM		 11365
11366 case Tag_ABI_conformance:
11367 printf (" Tag_ABI_conformance: ");
11368 printf ("\"%s\"\n", p);
11369 p += strlen ((char *) p) + 1;
11370 return p;
59e6276b
JM		 11371 }
11372
11373 printf (" Tag_unknown_%d: ", tag);
11374
87779176
JM		 11375 if (tag & 1)
11376 {
11377 printf ("\"%s\"\n", p);
11378 p += strlen ((char *) p) + 1;
11379 }
11380 else
11381 {
11382 val = read_uleb128 (p, &len);
11383 p += len;
11384 printf ("%d (0x%x)\n", val, val);
11385 }
59e6276b
JM		 11386
11387 return p;
11388}
11389
11c1ff18 11390static int
60bca95a
NC		 11391process_attributes (FILE * file,
11392 const char * public_name,
104d59d1 11393 unsigned int proc_type,
60bca95a
NC		 11394 unsigned char * (* display_pub_attribute) (unsigned char *),
11395 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11396{
2cf0635d
NC		 11397 Elf_Internal_Shdr * sect;
11398 unsigned char * contents;
11399 unsigned char * p;
11400 unsigned char * end;
11c1ff18
PB		 11401 bfd_vma section_len;
11402 bfd_vma len;
11403 unsigned i;
11404
11405 /* Find the section header so that we get the size. */
11406 for (i = 0, sect = section_headers;
11407 i < elf_header.e_shnum;
11408 i++, sect++)
11409 {
104d59d1 11410 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11411 continue;
11412
3f5e193b
NC		 11413 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11414 sect->sh_size, _("attributes"));
60bca95a 11415 if (contents == NULL)
11c1ff18 11416 continue;
60bca95a 11417
11c1ff18
PB		 11418 p = contents;
11419 if (*p == 'A')
11420 {
11421 len = sect->sh_size - 1;
11422 p++;
60bca95a 11423
11c1ff18
PB		 11424 while (len > 0)
11425 {
11426 int namelen;
11427 bfd_boolean public_section;
104d59d1 11428 bfd_boolean gnu_section;
11c1ff18
PB		 11429
11430 section_len = byte_get (p, 4);
11431 p += 4;
60bca95a 11432
11c1ff18
PB		 11433 if (section_len > len)
11434 {
11435 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11436 (int) section_len, (int) len);
11c1ff18
PB		 11437 section_len = len;
11438 }
60bca95a 11439
11c1ff18 11440 len -= section_len;
2b692964 11441 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11442
11443 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11444 public_section = TRUE;
11445 else
11446 public_section = FALSE;
60bca95a
NC		 11447
11448 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11449 gnu_section = TRUE;
11450 else
11451 gnu_section = FALSE;
60bca95a
NC		 11452
11453 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11454 p += namelen;
11455 section_len -= namelen + 4;
60bca95a 11456
11c1ff18
PB		 11457 while (section_len > 0)
11458 {
11459 int tag = *(p++);
11460 int val;
11461 bfd_vma size;
60bca95a 11462
11c1ff18
PB		 11463 size = byte_get (p, 4);
11464 if (size > section_len)
11465 {
11466 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11467 (int) size, (int) section_len);
11c1ff18
PB		 11468 size = section_len;
11469 }
60bca95a 11470
11c1ff18
PB		 11471 section_len -= size;
11472 end = p + size - 1;
11473 p += 4;
60bca95a 11474
11c1ff18
PB		 11475 switch (tag)
11476 {
11477 case 1:
2b692964 11478 printf (_("File Attributes\n"));
11c1ff18
PB		 11479 break;
11480 case 2:
2b692964 11481 printf (_("Section Attributes:"));
11c1ff18
PB		 11482 goto do_numlist;
11483 case 3:
2b692964 11484 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11485 do_numlist:
11486 for (;;)
11487 {
91d6fa6a 11488 unsigned int j;
60bca95a 11489
91d6fa6a
NC		 11490 val = read_uleb128 (p, &j);
11491 p += j;
11c1ff18
PB		 11492 if (val == 0)
11493 break;
11494 printf (" %d", val);
11495 }
11496 printf ("\n");
11497 break;
11498 default:
2b692964 11499 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11500 public_section = FALSE;
11501 break;
11502 }
60bca95a 11503
11c1ff18
PB		 11504 if (public_section)
11505 {
11506 while (p < end)
104d59d1
JM		 11507 p = display_pub_attribute (p);
11508 }
11509 else if (gnu_section)
11510 {
11511 while (p < end)
11512 p = display_gnu_attribute (p,
11513 display_proc_gnu_attribute);
11c1ff18
PB		 11514 }
11515 else
11516 {
11517 /* ??? Do something sensible, like dump hex. */
2b692964 11518 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11519 p = end;
11520 }
11521 }
11522 }
11523 }
11524 else
60bca95a 11525 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11526
60bca95a 11527 free (contents);
11c1ff18
PB		 11528 }
11529 return 1;
11530}
11531
104d59d1 11532static int
2cf0635d 11533process_arm_specific (FILE * file)
104d59d1
JM		 11534{
11535 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11536 display_arm_attribute, NULL);
11537}
11538
34c8bcba 11539static int
2cf0635d 11540process_power_specific (FILE * file)
34c8bcba
JM		 11541{
11542 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11543 display_power_gnu_attribute);
11544}
11545
59e6276b
JM		 11546static int
11547process_tic6x_specific (FILE * file)
11548{
11549 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11550 display_tic6x_attribute, NULL);
11551}
11552
ccb4c951
RS		 11553/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11554 Print the Address, Access and Initial fields of an entry at VMA ADDR
11555 and return the VMA of the next entry. */
11556
11557static bfd_vma
2cf0635d 11558print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11559{
11560 printf (" ");
11561 print_vma (addr, LONG_HEX);
11562 printf (" ");
11563 if (addr < pltgot + 0xfff0)
11564 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11565 else
11566 printf ("%10s", "");
11567 printf (" ");
11568 if (data == NULL)
2b692964 11569 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11570 else
11571 {
11572 bfd_vma entry;
11573
11574 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11575 print_vma (entry, LONG_HEX);
11576 }
11577 return addr + (is_32bit_elf ? 4 : 8);
11578}
11579
861fb55a
DJ		 11580/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11581 PLTGOT. Print the Address and Initial fields of an entry at VMA
11582 ADDR and return the VMA of the next entry. */
11583
11584static bfd_vma
2cf0635d 11585print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11586{
11587 printf (" ");
11588 print_vma (addr, LONG_HEX);
11589 printf (" ");
11590 if (data == NULL)
2b692964 11591 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11592 else
11593 {
11594 bfd_vma entry;
11595
11596 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11597 print_vma (entry, LONG_HEX);
11598 }
11599 return addr + (is_32bit_elf ? 4 : 8);
11600}
11601
19e6b90e 11602static int
2cf0635d 11603process_mips_specific (FILE * file)
5b18a4bc 11604{
2cf0635d 11605 Elf_Internal_Dyn * entry;
19e6b90e
L		 11606 size_t liblist_offset = 0;
11607 size_t liblistno = 0;
11608 size_t conflictsno = 0;
11609 size_t options_offset = 0;
11610 size_t conflicts_offset = 0;
861fb55a
DJ		 11611 size_t pltrelsz = 0;
11612 size_t pltrel = 0;
ccb4c951 11613 bfd_vma pltgot = 0;
861fb55a
DJ		 11614 bfd_vma mips_pltgot = 0;
11615 bfd_vma jmprel = 0;
ccb4c951
RS		 11616 bfd_vma local_gotno = 0;
11617 bfd_vma gotsym = 0;
11618 bfd_vma symtabno = 0;
103f02d3 11619
2cf19d5c
JM		 11620 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11621 display_mips_gnu_attribute);
11622
19e6b90e
L		 11623 /* We have a lot of special sections. Thanks SGI! */
11624 if (dynamic_section == NULL)
11625 /* No information available. */
11626 return 0;
252b5132 11627
b2d38a17 11628 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11629 switch (entry->d_tag)
11630 {
11631 case DT_MIPS_LIBLIST:
d93f0186
NC		 11632 liblist_offset
11633 = offset_from_vma (file, entry->d_un.d_val,
11634 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11635 break;
11636 case DT_MIPS_LIBLISTNO:
11637 liblistno = entry->d_un.d_val;
11638 break;
11639 case DT_MIPS_OPTIONS:
d93f0186 11640 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11641 break;
11642 case DT_MIPS_CONFLICT:
d93f0186
NC		 11643 conflicts_offset
11644 = offset_from_vma (file, entry->d_un.d_val,
11645 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11646 break;
11647 case DT_MIPS_CONFLICTNO:
11648 conflictsno = entry->d_un.d_val;
11649 break;
ccb4c951 11650 case DT_PLTGOT:
861fb55a
DJ		 11651 pltgot = entry->d_un.d_ptr;
11652 break;
ccb4c951
RS		 11653 case DT_MIPS_LOCAL_GOTNO:
11654 local_gotno = entry->d_un.d_val;
11655 break;
11656 case DT_MIPS_GOTSYM:
11657 gotsym = entry->d_un.d_val;
11658 break;
11659 case DT_MIPS_SYMTABNO:
11660 symtabno = entry->d_un.d_val;
11661 break;
861fb55a
DJ		 11662 case DT_MIPS_PLTGOT:
11663 mips_pltgot = entry->d_un.d_ptr;
11664 break;
11665 case DT_PLTREL:
11666 pltrel = entry->d_un.d_val;
11667 break;
11668 case DT_PLTRELSZ:
11669 pltrelsz = entry->d_un.d_val;
11670 break;
11671 case DT_JMPREL:
11672 jmprel = entry->d_un.d_ptr;
11673 break;
252b5132
RH		 11674 default:
11675 break;
11676 }
11677
11678 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11679 {
2cf0635d 11680 Elf32_External_Lib * elib;
252b5132
RH		 11681 size_t cnt;
11682
3f5e193b
NC		 11683 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11684 liblistno,
11685 sizeof (Elf32_External_Lib),
11686 _("liblist"));
a6e9f9df 11687 if (elib)
252b5132 11688 {
2b692964 11689 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11690 (unsigned long) liblistno);
2b692964 11691 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11692 stdout);
11693
11694 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11695 {
a6e9f9df 11696 Elf32_Lib liblist;
91d6fa6a 11697 time_t atime;
a6e9f9df 11698 char timebuf[20];
2cf0635d 11699 struct tm * tmp;
a6e9f9df
AM		 11700
11701 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11702 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11703 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11704 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11705 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11706
91d6fa6a 11707 tmp = gmtime (&atime);
e9e44622
JJ		 11708 snprintf (timebuf, sizeof (timebuf),
11709 "%04u-%02u-%02uT%02u:%02u:%02u",
11710 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11711 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11712
31104126 11713 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11714 if (VALID_DYNAMIC_NAME (liblist.l_name))
11715 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11716 else
2b692964 11717 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11718 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11719 liblist.l_version);
a6e9f9df
AM		 11720
11721 if (liblist.l_flags == 0)
2b692964 11722 puts (_(" NONE"));
a6e9f9df
AM		 11723 else
11724 {
11725 static const struct
252b5132 11726 {
2cf0635d 11727 const char * name;
a6e9f9df 11728 int bit;
252b5132 11729 }
a6e9f9df
AM		 11730 l_flags_vals[] =
11731 {
11732 { " EXACT_MATCH", LL_EXACT_MATCH },
11733 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11734 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11735 { " EXPORTS", LL_EXPORTS },
11736 { " DELAY_LOAD", LL_DELAY_LOAD },
11737 { " DELTA", LL_DELTA }
11738 };
11739 int flags = liblist.l_flags;
11740 size_t fcnt;
11741
60bca95a 11742 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 11743 if ((flags & l_flags_vals[fcnt].bit) != 0)
11744 {
11745 fputs (l_flags_vals[fcnt].name, stdout);
11746 flags ^= l_flags_vals[fcnt].bit;
11747 }
11748 if (flags != 0)
11749 printf (" %#x", (unsigned int) flags);
252b5132 11750
a6e9f9df
AM		 11751 puts ("");
11752 }
252b5132 11753 }
252b5132 11754
a6e9f9df
AM		 11755 free (elib);
11756 }
252b5132
RH		 11757 }
11758
11759 if (options_offset != 0)
11760 {
2cf0635d
NC		 11761 Elf_External_Options * eopt;
11762 Elf_Internal_Shdr * sect = section_headers;
11763 Elf_Internal_Options * iopt;
11764 Elf_Internal_Options * option;
252b5132
RH		 11765 size_t offset;
11766 int cnt;
11767
11768 /* Find the section header so that we get the size. */
11769 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 11770 ++sect;
252b5132 11771
3f5e193b
NC		 11772 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11773 sect->sh_size, _("options"));
a6e9f9df 11774 if (eopt)
252b5132 11775 {
3f5e193b
NC		 11776 iopt = (Elf_Internal_Options *)
11777 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 11778 if (iopt == NULL)
11779 {
591a748a 11780 error (_("Out of memory\n"));
a6e9f9df
AM		 11781 return 0;
11782 }
76da6bbe 11783
a6e9f9df
AM		 11784 offset = cnt = 0;
11785 option = iopt;
252b5132 11786
a6e9f9df
AM		 11787 while (offset < sect->sh_size)
11788 {
2cf0635d 11789 Elf_External_Options * eoption;
252b5132 11790
a6e9f9df 11791 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 11792
a6e9f9df
AM		 11793 option->kind = BYTE_GET (eoption->kind);
11794 option->size = BYTE_GET (eoption->size);
11795 option->section = BYTE_GET (eoption->section);
11796 option->info = BYTE_GET (eoption->info);
76da6bbe 11797
a6e9f9df 11798 offset += option->size;
252b5132 11799
a6e9f9df
AM		 11800 ++option;
11801 ++cnt;
11802 }
252b5132 11803
a6e9f9df
AM		 11804 printf (_("\nSection '%s' contains %d entries:\n"),
11805 SECTION_NAME (sect), cnt);
76da6bbe 11806
a6e9f9df 11807 option = iopt;
252b5132 11808
a6e9f9df 11809 while (cnt-- > 0)
252b5132 11810 {
a6e9f9df
AM		 11811 size_t len;
11812
11813 switch (option->kind)
252b5132 11814 {
a6e9f9df
AM		 11815 case ODK_NULL:
11816 /* This shouldn't happen. */
11817 printf (" NULL %d %lx", option->section, option->info);
11818 break;
11819 case ODK_REGINFO:
11820 printf (" REGINFO ");
11821 if (elf_header.e_machine == EM_MIPS)
11822 {
11823 /* 32bit form. */
2cf0635d 11824 Elf32_External_RegInfo * ereg;
b34976b6 11825 Elf32_RegInfo reginfo;
a6e9f9df
AM		 11826
11827 ereg = (Elf32_External_RegInfo *) (option + 1);
11828 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11829 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11830 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11831 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11832 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11833 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11834
11835 printf ("GPR %08lx GP 0x%lx\n",
11836 reginfo.ri_gprmask,
11837 (unsigned long) reginfo.ri_gp_value);
11838 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11839 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11840 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11841 }
11842 else
11843 {
11844 /* 64 bit form. */
2cf0635d 11845 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 11846 Elf64_Internal_RegInfo reginfo;
11847
11848 ereg = (Elf64_External_RegInfo *) (option + 1);
11849 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11850 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11851 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11852 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11853 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 11854 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 11855
11856 printf ("GPR %08lx GP 0x",
11857 reginfo.ri_gprmask);
11858 printf_vma (reginfo.ri_gp_value);
11859 printf ("\n");
11860
11861 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11862 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11863 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11864 }
11865 ++option;
11866 continue;
11867 case ODK_EXCEPTIONS:
11868 fputs (" EXCEPTIONS fpe_min(", stdout);
11869 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11870 fputs (") fpe_max(", stdout);
11871 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11872 fputs (")", stdout);
11873
11874 if (option->info & OEX_PAGE0)
11875 fputs (" PAGE0", stdout);
11876 if (option->info & OEX_SMM)
11877 fputs (" SMM", stdout);
11878 if (option->info & OEX_FPDBUG)
11879 fputs (" FPDBUG", stdout);
11880 if (option->info & OEX_DISMISS)
11881 fputs (" DISMISS", stdout);
11882 break;
11883 case ODK_PAD:
11884 fputs (" PAD ", stdout);
11885 if (option->info & OPAD_PREFIX)
11886 fputs (" PREFIX", stdout);
11887 if (option->info & OPAD_POSTFIX)
11888 fputs (" POSTFIX", stdout);
11889 if (option->info & OPAD_SYMBOL)
11890 fputs (" SYMBOL", stdout);
11891 break;
11892 case ODK_HWPATCH:
11893 fputs (" HWPATCH ", stdout);
11894 if (option->info & OHW_R4KEOP)
11895 fputs (" R4KEOP", stdout);
11896 if (option->info & OHW_R8KPFETCH)
11897 fputs (" R8KPFETCH", stdout);
11898 if (option->info & OHW_R5KEOP)
11899 fputs (" R5KEOP", stdout);
11900 if (option->info & OHW_R5KCVTL)
11901 fputs (" R5KCVTL", stdout);
11902 break;
11903 case ODK_FILL:
11904 fputs (" FILL ", stdout);
11905 /* XXX Print content of info word? */
11906 break;
11907 case ODK_TAGS:
11908 fputs (" TAGS ", stdout);
11909 /* XXX Print content of info word? */
11910 break;
11911 case ODK_HWAND:
11912 fputs (" HWAND ", stdout);
11913 if (option->info & OHWA0_R4KEOP_CHECKED)
11914 fputs (" R4KEOP_CHECKED", stdout);
11915 if (option->info & OHWA0_R4KEOP_CLEAN)
11916 fputs (" R4KEOP_CLEAN", stdout);
11917 break;
11918 case ODK_HWOR:
11919 fputs (" HWOR ", stdout);
11920 if (option->info & OHWA0_R4KEOP_CHECKED)
11921 fputs (" R4KEOP_CHECKED", stdout);
11922 if (option->info & OHWA0_R4KEOP_CLEAN)
11923 fputs (" R4KEOP_CLEAN", stdout);
11924 break;
11925 case ODK_GP_GROUP:
11926 printf (" GP_GROUP %#06lx self-contained %#06lx",
11927 option->info & OGP_GROUP,
11928 (option->info & OGP_SELF) >> 16);
11929 break;
11930 case ODK_IDENT:
11931 printf (" IDENT %#06lx self-contained %#06lx",
11932 option->info & OGP_GROUP,
11933 (option->info & OGP_SELF) >> 16);
11934 break;
11935 default:
11936 /* This shouldn't happen. */
11937 printf (" %3d ??? %d %lx",
11938 option->kind, option->section, option->info);
11939 break;
252b5132 11940 }
a6e9f9df 11941
2cf0635d 11942 len = sizeof (* eopt);
a6e9f9df
AM		 11943 while (len < option->size)
11944 if (((char *) option)[len] >= ' '
11945 && ((char *) option)[len] < 0x7f)
11946 printf ("%c", ((char *) option)[len++]);
11947 else
11948 printf ("\\%03o", ((char *) option)[len++]);
11949
11950 fputs ("\n", stdout);
252b5132 11951 ++option;
252b5132
RH		 11952 }
11953
a6e9f9df 11954 free (eopt);
252b5132 11955 }
252b5132
RH		 11956 }
11957
11958 if (conflicts_offset != 0 && conflictsno != 0)
11959 {
2cf0635d 11960 Elf32_Conflict * iconf;
252b5132
RH		 11961 size_t cnt;
11962
11963 if (dynamic_symbols == NULL)
11964 {
591a748a 11965 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 11966 return 0;
11967 }
11968
3f5e193b 11969 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 11970 if (iconf == NULL)
11971 {
591a748a 11972 error (_("Out of memory\n"));
252b5132
RH		 11973 return 0;
11974 }
11975
9ea033b2 11976 if (is_32bit_elf)
252b5132 11977 {
2cf0635d 11978 Elf32_External_Conflict * econf32;
a6e9f9df 11979
3f5e193b
NC		 11980 econf32 = (Elf32_External_Conflict *)
11981 get_data (NULL, file, conflicts_offset, conflictsno,
11982 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 11983 if (!econf32)
11984 return 0;
252b5132
RH		 11985
11986 for (cnt = 0; cnt < conflictsno; ++cnt)
11987 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 11988
11989 free (econf32);
252b5132
RH		 11990 }
11991 else
11992 {
2cf0635d 11993 Elf64_External_Conflict * econf64;
a6e9f9df 11994
3f5e193b
NC		 11995 econf64 = (Elf64_External_Conflict *)
11996 get_data (NULL, file, conflicts_offset, conflictsno,
11997 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 11998 if (!econf64)
11999 return 0;
252b5132
RH		 12000
12001 for (cnt = 0; cnt < conflictsno; ++cnt)
12002 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12003
12004 free (econf64);
252b5132
RH		 12005 }
12006
c7e7ca54
NC		 12007 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12008 (unsigned long) conflictsno);
252b5132
RH		 12009 puts (_(" Num: Index Value Name"));
12010
12011 for (cnt = 0; cnt < conflictsno; ++cnt)
12012 {
2cf0635d 12013 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12014
b34976b6 12015 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12016 print_vma (psym->st_value, FULL_HEX);
31104126 12017 putchar (' ');
d79b3d50
NC		 12018 if (VALID_DYNAMIC_NAME (psym->st_name))
12019 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12020 else
2b692964 12021 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12022 putchar ('\n');
252b5132
RH		 12023 }
12024
252b5132
RH		 12025 free (iconf);
12026 }
12027
ccb4c951
RS		 12028 if (pltgot != 0 && local_gotno != 0)
12029 {
91d6fa6a 12030 bfd_vma ent, local_end, global_end;
bbeee7ea 12031 size_t i, offset;
2cf0635d 12032 unsigned char * data;
bbeee7ea 12033 int addr_size;
ccb4c951 12034
91d6fa6a 12035 ent = pltgot;
ccb4c951
RS		 12036 addr_size = (is_32bit_elf ? 4 : 8);
12037 local_end = pltgot + local_gotno * addr_size;
12038 global_end = local_end + (symtabno - gotsym) * addr_size;
12039
12040 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b
NC		 12041 data = (unsigned char *) get_data (NULL, file, offset,
12042 global_end - pltgot, 1, _("GOT"));
59245841
NC		 12043 if (data == NULL)
12044 return 0;
12045
ccb4c951
RS		 12046 printf (_("\nPrimary GOT:\n"));
12047 printf (_(" Canonical gp value: "));
12048 print_vma (pltgot + 0x7ff0, LONG_HEX);
12049 printf ("\n\n");
12050
12051 printf (_(" Reserved entries:\n"));
12052 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12053 addr_size * 2, _("Address"), _("Access"),
12054 addr_size * 2, _("Initial"));
91d6fa6a 12055 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12056 printf (_(" Lazy resolver\n"));
ccb4c951 12057 if (data
91d6fa6a 12058 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12059 >> (addr_size * 8 - 1)) != 0)
12060 {
91d6fa6a 12061 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12062 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12063 }
12064 printf ("\n");
12065
91d6fa6a 12066 if (ent < local_end)
ccb4c951
RS		 12067 {
12068 printf (_(" Local entries:\n"));
cc5914eb 12069 printf (" %*s %10s %*s\n",
2b692964
NC		 12070 addr_size * 2, _("Address"), _("Access"),
12071 addr_size * 2, _("Initial"));
91d6fa6a 12072 while (ent < local_end)
ccb4c951 12073 {
91d6fa6a 12074 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12075 printf ("\n");
12076 }
12077 printf ("\n");
12078 }
12079
12080 if (gotsym < symtabno)
12081 {
12082 int sym_width;
12083
12084 printf (_(" Global entries:\n"));
cc5914eb 12085 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12086 addr_size * 2, _("Address"), _("Access"),
12087 addr_size * 2, _("Initial"),
12088 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
ccb4c951
RS		 12089 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12090 for (i = gotsym; i < symtabno; i++)
12091 {
2cf0635d 12092 Elf_Internal_Sym * psym;
ccb4c951
RS		 12093
12094 psym = dynamic_symbols + i;
91d6fa6a 12095 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12096 printf (" ");
12097 print_vma (psym->st_value, LONG_HEX);
12098 printf (" %-7s %3s ",
12099 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12100 get_symbol_index_type (psym->st_shndx));
12101 if (VALID_DYNAMIC_NAME (psym->st_name))
12102 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12103 else
2b692964 12104 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12105 printf ("\n");
12106 }
12107 printf ("\n");
12108 }
12109
12110 if (data)
12111 free (data);
12112 }
12113
861fb55a
DJ		 12114 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12115 {
91d6fa6a 12116 bfd_vma ent, end;
861fb55a
DJ		 12117 size_t offset, rel_offset;
12118 unsigned long count, i;
2cf0635d 12119 unsigned char * data;
861fb55a 12120 int addr_size, sym_width;
2cf0635d 12121 Elf_Internal_Rela * rels;
861fb55a
DJ		 12122
12123 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12124 if (pltrel == DT_RELA)
12125 {
12126 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12127 return 0;
12128 }
12129 else
12130 {
12131 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12132 return 0;
12133 }
12134
91d6fa6a 12135 ent = mips_pltgot;
861fb55a
DJ		 12136 addr_size = (is_32bit_elf ? 4 : 8);
12137 end = mips_pltgot + (2 + count) * addr_size;
12138
12139 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b
NC		 12140 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12141 1, _("PLT GOT"));
59245841
NC		 12142 if (data == NULL)
12143 return 0;
12144
861fb55a
DJ		 12145 printf (_("\nPLT GOT:\n\n"));
12146 printf (_(" Reserved entries:\n"));
12147 printf (_(" %*s %*s Purpose\n"),
2b692964 12148 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12149 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12150 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12151 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12152 printf (_(" Module pointer\n"));
861fb55a
DJ		 12153 printf ("\n");
12154
12155 printf (_(" Entries:\n"));
cc5914eb 12156 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12157 addr_size * 2, _("Address"),
12158 addr_size * 2, _("Initial"),
12159 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12160 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12161 for (i = 0; i < count; i++)
12162 {
2cf0635d 12163 Elf_Internal_Sym * psym;
861fb55a
DJ		 12164
12165 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12166 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12167 printf (" ");
12168 print_vma (psym->st_value, LONG_HEX);
12169 printf (" %-7s %3s ",
12170 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12171 get_symbol_index_type (psym->st_shndx));
12172 if (VALID_DYNAMIC_NAME (psym->st_name))
12173 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12174 else
2b692964 12175 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12176 printf ("\n");
12177 }
12178 printf ("\n");
12179
12180 if (data)
12181 free (data);
12182 free (rels);
12183 }
12184
252b5132
RH		 12185 return 1;
12186}
12187
047b2264 12188static int
2cf0635d 12189process_gnu_liblist (FILE * file)
047b2264 12190{
2cf0635d
NC		 12191 Elf_Internal_Shdr * section;
12192 Elf_Internal_Shdr * string_sec;
12193 Elf32_External_Lib * elib;
12194 char * strtab;
c256ffe7 12195 size_t strtab_size;
047b2264
JJ		 12196 size_t cnt;
12197 unsigned i;
12198
12199 if (! do_arch)
12200 return 0;
12201
12202 for (i = 0, section = section_headers;
12203 i < elf_header.e_shnum;
b34976b6 12204 i++, section++)
047b2264
JJ		 12205 {
12206 switch (section->sh_type)
12207 {
12208 case SHT_GNU_LIBLIST:
4fbb74a6 12209 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12210 break;
12211
3f5e193b
NC		 12212 elib = (Elf32_External_Lib *)
12213 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12214 _("liblist"));
047b2264
JJ		 12215
12216 if (elib == NULL)
12217 break;
4fbb74a6 12218 string_sec = section_headers + section->sh_link;
047b2264 12219
3f5e193b
NC		 12220 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12221 string_sec->sh_size,
12222 _("liblist string table"));
047b2264
JJ		 12223 if (strtab == NULL
12224 || section->sh_entsize != sizeof (Elf32_External_Lib))
12225 {
12226 free (elib);
2842702f 12227 free (strtab);
047b2264
JJ		 12228 break;
12229 }
59245841 12230 strtab_size = string_sec->sh_size;
047b2264
JJ		 12231
12232 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12233 SECTION_NAME (section),
0af1713e 12234 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12235
2b692964 12236 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12237
12238 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12239 ++cnt)
12240 {
12241 Elf32_Lib liblist;
91d6fa6a 12242 time_t atime;
047b2264 12243 char timebuf[20];
2cf0635d 12244 struct tm * tmp;
047b2264
JJ		 12245
12246 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12247 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12248 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12249 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12250 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12251
91d6fa6a 12252 tmp = gmtime (&atime);
e9e44622
JJ		 12253 snprintf (timebuf, sizeof (timebuf),
12254 "%04u-%02u-%02uT%02u:%02u:%02u",
12255 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12256 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12257
12258 printf ("%3lu: ", (unsigned long) cnt);
12259 if (do_wide)
c256ffe7 12260 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12261 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12262 else
c256ffe7 12263 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12264 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12265 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12266 liblist.l_version, liblist.l_flags);
12267 }
12268
12269 free (elib);
2842702f 12270 free (strtab);
047b2264
JJ		 12271 }
12272 }
12273
12274 return 1;
12275}
12276
9437c45b 12277static const char *
d3ba0551 12278get_note_type (unsigned e_type)
779fe533
NC		 12279{
12280 static char buff[64];
103f02d3 12281
1ec5cd37
NC		 12282 if (elf_header.e_type == ET_CORE)
12283 switch (e_type)
12284 {
57346661 12285 case NT_AUXV:
1ec5cd37 12286 return _("NT_AUXV (auxiliary vector)");
57346661 12287 case NT_PRSTATUS:
1ec5cd37 12288 return _("NT_PRSTATUS (prstatus structure)");
57346661 12289 case NT_FPREGSET:
1ec5cd37 12290 return _("NT_FPREGSET (floating point registers)");
57346661 12291 case NT_PRPSINFO:
1ec5cd37 12292 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12293 case NT_TASKSTRUCT:
1ec5cd37 12294 return _("NT_TASKSTRUCT (task structure)");
57346661 12295 case NT_PRXFPREG:
1ec5cd37 12296 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12297 case NT_PPC_VMX:
12298 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12299 case NT_PPC_VSX:
12300 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12301 case NT_X86_XSTATE:
12302 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12303 case NT_S390_HIGH_GPRS:
12304 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12305 case NT_S390_TIMER:
12306 return _("NT_S390_TIMER (s390 timer register)");
12307 case NT_S390_TODCMP:
12308 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12309 case NT_S390_TODPREG:
12310 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12311 case NT_S390_CTRS:
12312 return _("NT_S390_CTRS (s390 control registers)");
12313 case NT_S390_PREFIX:
12314 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12315 case NT_ARM_VFP:
12316 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12317 case NT_PSTATUS:
1ec5cd37 12318 return _("NT_PSTATUS (pstatus structure)");
57346661 12319 case NT_FPREGS:
1ec5cd37 12320 return _("NT_FPREGS (floating point registers)");
57346661 12321 case NT_PSINFO:
1ec5cd37 12322 return _("NT_PSINFO (psinfo structure)");
57346661 12323 case NT_LWPSTATUS:
1ec5cd37 12324 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12325 case NT_LWPSINFO:
1ec5cd37 12326 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12327 case NT_WIN32PSTATUS:
1ec5cd37
NC		 12328 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12329 default:
12330 break;
12331 }
12332 else
12333 switch (e_type)
12334 {
12335 case NT_VERSION:
12336 return _("NT_VERSION (version)");
12337 case NT_ARCH:
12338 return _("NT_ARCH (architecture)");
12339 default:
12340 break;
12341 }
12342
e9e44622 12343 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12344 return buff;
779fe533
NC		 12345}
12346
1118d252
RM		 12347static const char *
12348get_gnu_elf_note_type (unsigned e_type)
12349{
12350 static char buff[64];
12351
12352 switch (e_type)
12353 {
12354 case NT_GNU_ABI_TAG:
12355 return _("NT_GNU_ABI_TAG (ABI version tag)");
12356 case NT_GNU_HWCAP:
12357 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12358 case NT_GNU_BUILD_ID:
12359 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12360 case NT_GNU_GOLD_VERSION:
12361 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12362 default:
12363 break;
12364 }
12365
12366 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12367 return buff;
12368}
12369
664f90a3
TT		 12370static int
12371print_gnu_note (Elf_Internal_Note *pnote)
12372{
12373 switch (pnote->type)
12374 {
12375 case NT_GNU_BUILD_ID:
12376 {
12377 unsigned long i;
12378
12379 printf (_(" Build ID: "));
12380 for (i = 0; i < pnote->descsz; ++i)
12381 printf ("%02x", pnote->descdata[i] & 0xff);
12382 printf (_("\n"));
12383 }
12384 break;
12385
12386 case NT_GNU_ABI_TAG:
12387 {
12388 unsigned long os, major, minor, subminor;
12389 const char *osname;
12390
12391 os = byte_get ((unsigned char *) pnote->descdata, 4);
12392 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12393 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12394 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12395
12396 switch (os)
12397 {
12398 case GNU_ABI_TAG_LINUX:
12399 osname = "Linux";
12400 break;
12401 case GNU_ABI_TAG_HURD:
12402 osname = "Hurd";
12403 break;
12404 case GNU_ABI_TAG_SOLARIS:
12405 osname = "Solaris";
12406 break;
12407 case GNU_ABI_TAG_FREEBSD:
12408 osname = "FreeBSD";
12409 break;
12410 case GNU_ABI_TAG_NETBSD:
12411 osname = "NetBSD";
12412 break;
12413 default:
12414 osname = "Unknown";
12415 break;
12416 }
12417
12418 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12419 major, minor, subminor);
12420 }
12421 break;
12422 }
12423
12424 return 1;
12425}
12426
9437c45b 12427static const char *
d3ba0551 12428get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12429{
12430 static char buff[64];
12431
b4db1224 12432 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12433 {
12434 /* NetBSD core "procinfo" structure. */
12435 return _("NetBSD procinfo structure");
12436 }
12437
12438 /* As of Jan 2002 there are no other machine-independent notes
12439 defined for NetBSD core files. If the note type is less
12440 than the start of the machine-dependent note types, we don't
12441 understand it. */
12442
b4db1224 12443 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12444 {
e9e44622 12445 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12446 return buff;
12447 }
12448
12449 switch (elf_header.e_machine)
12450 {
12451 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12452 and PT_GETFPREGS == mach+2. */
12453
12454 case EM_OLD_ALPHA:
12455 case EM_ALPHA:
12456 case EM_SPARC:
12457 case EM_SPARC32PLUS:
12458 case EM_SPARCV9:
12459 switch (e_type)
12460 {
2b692964 12461 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12462 return _("PT_GETREGS (reg structure)");
2b692964 12463 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12464 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12465 default:
12466 break;
12467 }
12468 break;
12469
12470 /* On all other arch's, PT_GETREGS == mach+1 and
12471 PT_GETFPREGS == mach+3. */
12472 default:
12473 switch (e_type)
12474 {
2b692964 12475 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12476 return _("PT_GETREGS (reg structure)");
2b692964 12477 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12478 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12479 default:
12480 break;
12481 }
12482 }
12483
e9e44622
JJ		 12484 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12485 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12486 return buff;
12487}
12488
70616151
TT		 12489static const char *
12490get_stapsdt_note_type (unsigned e_type)
12491{
12492 static char buff[64];
12493
12494 switch (e_type)
12495 {
12496 case NT_STAPSDT:
12497 return _("NT_STAPSDT (SystemTap probe descriptors)");
12498
12499 default:
12500 break;
12501 }
12502
12503 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12504 return buff;
12505}
12506
c6a9fc58
TT		 12507static int
12508print_stapsdt_note (Elf_Internal_Note *pnote)
12509{
12510 int addr_size = is_32bit_elf ? 4 : 8;
12511 char *data = pnote->descdata;
12512 char *data_end = pnote->descdata + pnote->descsz;
12513 bfd_vma pc, base_addr, semaphore;
12514 char *provider, *probe, *arg_fmt;
12515
12516 pc = byte_get ((unsigned char *) data, addr_size);
12517 data += addr_size;
12518 base_addr = byte_get ((unsigned char *) data, addr_size);
12519 data += addr_size;
12520 semaphore = byte_get ((unsigned char *) data, addr_size);
12521 data += addr_size;
12522
12523 provider = data;
12524 data += strlen (data) + 1;
12525 probe = data;
12526 data += strlen (data) + 1;
12527 arg_fmt = data;
12528 data += strlen (data) + 1;
12529
12530 printf (_(" Provider: %s\n"), provider);
12531 printf (_(" Name: %s\n"), probe);
12532 printf (_(" Location: "));
12533 print_vma (pc, FULL_HEX);
12534 printf (_(", Base: "));
12535 print_vma (base_addr, FULL_HEX);
12536 printf (_(", Semaphore: "));
12537 print_vma (semaphore, FULL_HEX);
12538 printf (_("\n"));
12539 printf (_(" Arguments: %s\n"), arg_fmt);
12540
12541 return data == data_end;
12542}
12543
00e98fc7
TG		 12544static const char *
12545get_ia64_vms_note_type (unsigned e_type)
12546{
12547 static char buff[64];
12548
12549 switch (e_type)
12550 {
12551 case NT_VMS_MHD:
12552 return _("NT_VMS_MHD (module header)");
12553 case NT_VMS_LNM:
12554 return _("NT_VMS_LNM (language name)");
12555 case NT_VMS_SRC:
12556 return _("NT_VMS_SRC (source files)");
12557 case NT_VMS_TITLE:
12558 return _("NT_VMS_TITLE");
12559 case NT_VMS_EIDC:
12560 return _("NT_VMS_EIDC (consistency check)");
12561 case NT_VMS_FPMODE:
12562 return _("NT_VMS_FPMODE (FP mode)");
12563 case NT_VMS_LINKTIME:
12564 return _("NT_VMS_LINKTIME");
12565 case NT_VMS_IMGNAM:
12566 return _("NT_VMS_IMGNAM (image name)");
12567 case NT_VMS_IMGID:
12568 return _("NT_VMS_IMGID (image id)");
12569 case NT_VMS_LINKID:
12570 return _("NT_VMS_LINKID (link id)");
12571 case NT_VMS_IMGBID:
12572 return _("NT_VMS_IMGBID (build id)");
12573 case NT_VMS_GSTNAM:
12574 return _("NT_VMS_GSTNAM (sym table name)");
12575 case NT_VMS_ORIG_DYN:
12576 return _("NT_VMS_ORIG_DYN");
12577 case NT_VMS_PATCHTIME:
12578 return _("NT_VMS_PATCHTIME");
12579 default:
12580 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12581 return buff;
12582 }
12583}
12584
12585static int
12586print_ia64_vms_note (Elf_Internal_Note * pnote)
12587{
12588 switch (pnote->type)
12589 {
12590 case NT_VMS_MHD:
12591 if (pnote->descsz > 36)
12592 {
12593 size_t l = strlen (pnote->descdata + 34);
12594 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12595 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12596 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12597 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12598 }
12599 else
12600 printf (_(" Invalid size\n"));
12601 break;
12602 case NT_VMS_LNM:
12603 printf (_(" Language: %s\n"), pnote->descdata);
12604 break;
12605#ifdef BFD64
12606 case NT_VMS_FPMODE:
12607 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12608 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12609 break;
12610 case NT_VMS_LINKTIME:
12611 printf (_(" Link time: "));
12612 print_vms_time
12613 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12614 printf ("\n");
12615 break;
12616 case NT_VMS_PATCHTIME:
12617 printf (_(" Patch time: "));
12618 print_vms_time
12619 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12620 printf ("\n");
12621 break;
12622 case NT_VMS_ORIG_DYN:
12623 printf (_(" Major id: %u, minor id: %u\n"),
12624 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12625 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12626 printf (_(" Manip date : "));
12627 print_vms_time
12628 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12629 printf (_("\n"
12630 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12631 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12632 printf (_(" Header flags: 0x%08x\n"),
12633 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12634 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12635 break;
12636#endif
12637 case NT_VMS_IMGNAM:
12638 printf (_(" Image name: %s\n"), pnote->descdata);
12639 break;
12640 case NT_VMS_GSTNAM:
12641 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12642 break;
12643 case NT_VMS_IMGID:
12644 printf (_(" Image id: %s\n"), pnote->descdata);
12645 break;
12646 case NT_VMS_LINKID:
12647 printf (_(" Linker id: %s\n"), pnote->descdata);
12648 break;
12649 default:
12650 break;
12651 }
12652 return 1;
12653}
12654
6d118b09
NC		 12655/* Note that by the ELF standard, the name field is already null byte
12656 terminated, and namesz includes the terminating null byte.
12657 I.E. the value of namesz for the name "FSF" is 4.
12658
e3c8793a 12659 If the value of namesz is zero, there is no name present. */
779fe533 12660static int
2cf0635d 12661process_note (Elf_Internal_Note * pnote)
779fe533 12662{
2cf0635d
NC		 12663 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12664 const char * nt;
9437c45b
JT		 12665
12666 if (pnote->namesz == 0)
1ec5cd37
NC		 12667 /* If there is no note name, then use the default set of
12668 note type strings. */
12669 nt = get_note_type (pnote->type);
12670
1118d252
RM		 12671 else if (const_strneq (pnote->namedata, "GNU"))
12672 /* GNU-specific object file notes. */
12673 nt = get_gnu_elf_note_type (pnote->type);
12674
0112cd26 12675 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 12676 /* NetBSD-specific core file notes. */
12677 nt = get_netbsd_elfcore_note_type (pnote->type);
12678
b15fa79e
AM		 12679 else if (strneq (pnote->namedata, "SPU/", 4))
12680 {
12681 /* SPU-specific core file notes. */
12682 nt = pnote->namedata + 4;
12683 name = "SPU";
12684 }
12685
00e98fc7
TG		 12686 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12687 /* VMS/ia64-specific file notes. */
12688 nt = get_ia64_vms_note_type (pnote->type);
12689
70616151
TT		 12690 else if (const_strneq (pnote->namedata, "stapsdt"))
12691 nt = get_stapsdt_note_type (pnote->type);
12692
9437c45b 12693 else
1ec5cd37
NC		 12694 /* Don't recognize this note name; just use the default set of
12695 note type strings. */
00e98fc7 12696 nt = get_note_type (pnote->type);
9437c45b 12697
2aee03ae 12698 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 12699
12700 if (const_strneq (pnote->namedata, "IPF/VMS"))
12701 return print_ia64_vms_note (pnote);
664f90a3
TT		 12702 else if (const_strneq (pnote->namedata, "GNU"))
12703 return print_gnu_note (pnote);
c6a9fc58
TT		 12704 else if (const_strneq (pnote->namedata, "stapsdt"))
12705 return print_stapsdt_note (pnote);
00e98fc7
TG		 12706 else
12707 return 1;
779fe533
NC		 12708}
12709
6d118b09 12710
779fe533 12711static int
2cf0635d 12712process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 12713{
2cf0635d
NC		 12714 Elf_External_Note * pnotes;
12715 Elf_External_Note * external;
b34976b6 12716 int res = 1;
103f02d3 12717
779fe533
NC		 12718 if (length <= 0)
12719 return 0;
103f02d3 12720
3f5e193b
NC		 12721 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12722 _("notes"));
dd24e3da 12723 if (pnotes == NULL)
a6e9f9df 12724 return 0;
779fe533 12725
103f02d3 12726 external = pnotes;
103f02d3 12727
305c7206 12728 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 12729 (unsigned long) offset, (unsigned long) length);
2aee03ae 12730 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 12731
2cf0635d 12732 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 12733 {
2cf0635d 12734 Elf_External_Note * next;
b34976b6 12735 Elf_Internal_Note inote;
2cf0635d 12736 char * temp = NULL;
6d118b09 12737
00e98fc7
TG		 12738 if (!is_ia64_vms ())
12739 {
12740 inote.type = BYTE_GET (external->type);
12741 inote.namesz = BYTE_GET (external->namesz);
12742 inote.namedata = external->name;
12743 inote.descsz = BYTE_GET (external->descsz);
12744 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12745 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12746
12747 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12748 }
12749 else
12750 {
12751 Elf64_External_VMS_Note *vms_external;
12752
12753 vms_external = (Elf64_External_VMS_Note *)external;
12754 inote.type = BYTE_GET (vms_external->type);
12755 inote.namesz = BYTE_GET (vms_external->namesz);
12756 inote.namedata = vms_external->name;
12757 inote.descsz = BYTE_GET (vms_external->descsz);
12758 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12759 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12760
12761 next = (Elf_External_Note *)
12762 (inote.descdata + align_power (inote.descsz, 3));
12763 }
3e55a963 12764
dd24e3da
NC		 12765 if ( ((char *) next > ((char *) pnotes) + length)
12766 || ((char *) next < (char *) pnotes))
3e55a963 12767 {
0fd3a477 12768 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 12769 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 12770 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 12771 inote.type, inote.namesz, inote.descsz);
12772 break;
12773 }
12774
12775 external = next;
6d118b09 12776
dd24e3da
NC		 12777 /* Prevent out-of-bounds indexing. */
12778 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12779 || inote.namedata + inote.namesz < inote.namedata)
12780 {
12781 warn (_("corrupt note found at offset %lx into core notes\n"),
12782 (unsigned long) ((char *) external - (char *) pnotes));
12783 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12784 inote.type, inote.namesz, inote.descsz);
12785 break;
12786 }
12787
6d118b09
NC		 12788 /* Verify that name is null terminated. It appears that at least
12789 one version of Linux (RedHat 6.0) generates corefiles that don't
12790 comply with the ELF spec by failing to include the null byte in
12791 namesz. */
12792 if (inote.namedata[inote.namesz] != '\0')
12793 {
3f5e193b 12794 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 12795
6d118b09
NC		 12796 if (temp == NULL)
12797 {
12798 error (_("Out of memory\n"));
12799 res = 0;
12800 break;
12801 }
76da6bbe 12802
6d118b09
NC		 12803 strncpy (temp, inote.namedata, inote.namesz);
12804 temp[inote.namesz] = 0;
76da6bbe 12805
6d118b09
NC		 12806 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12807 inote.namedata = temp;
12808 }
12809
12810 res &= process_note (& inote);
103f02d3 12811
6d118b09
NC		 12812 if (temp != NULL)
12813 {
12814 free (temp);
12815 temp = NULL;
12816 }
779fe533
NC		 12817 }
12818
12819 free (pnotes);
103f02d3 12820
779fe533
NC		 12821 return res;
12822}
12823
12824static int
2cf0635d 12825process_corefile_note_segments (FILE * file)
779fe533 12826{
2cf0635d 12827 Elf_Internal_Phdr * segment;
b34976b6
AM		 12828 unsigned int i;
12829 int res = 1;
103f02d3 12830
d93f0186 12831 if (! get_program_headers (file))
779fe533 12832 return 0;
103f02d3 12833
779fe533
NC		 12834 for (i = 0, segment = program_headers;
12835 i < elf_header.e_phnum;
b34976b6 12836 i++, segment++)
779fe533
NC		 12837 {
12838 if (segment->p_type == PT_NOTE)
103f02d3 12839 res &= process_corefile_note_segment (file,
30800947
NC		 12840 (bfd_vma) segment->p_offset,
12841 (bfd_vma) segment->p_filesz);
779fe533 12842 }
103f02d3 12843
779fe533
NC		 12844 return res;
12845}
12846
12847static int
2cf0635d 12848process_note_sections (FILE * file)
1ec5cd37 12849{
2cf0635d 12850 Elf_Internal_Shdr * section;
1ec5cd37
NC		 12851 unsigned long i;
12852 int res = 1;
12853
12854 for (i = 0, section = section_headers;
12855 i < elf_header.e_shnum;
12856 i++, section++)
12857 if (section->sh_type == SHT_NOTE)
12858 res &= process_corefile_note_segment (file,
12859 (bfd_vma) section->sh_offset,
12860 (bfd_vma) section->sh_size);
12861
12862 return res;
12863}
12864
12865static int
2cf0635d 12866process_notes (FILE * file)
779fe533
NC		 12867{
12868 /* If we have not been asked to display the notes then do nothing. */
12869 if (! do_notes)
12870 return 1;
103f02d3 12871
779fe533 12872 if (elf_header.e_type != ET_CORE)
1ec5cd37 12873 return process_note_sections (file);
103f02d3 12874
779fe533 12875 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 12876 if (elf_header.e_phnum > 0)
12877 return process_corefile_note_segments (file);
779fe533 12878
1ec5cd37
NC		 12879 printf (_("No note segments present in the core file.\n"));
12880 return 1;
779fe533
NC		 12881}
12882
252b5132 12883static int
2cf0635d 12884process_arch_specific (FILE * file)
252b5132 12885{
a952a375
NC		 12886 if (! do_arch)
12887 return 1;
12888
252b5132
RH		 12889 switch (elf_header.e_machine)
12890 {
11c1ff18
PB		 12891 case EM_ARM:
12892 return process_arm_specific (file);
252b5132 12893 case EM_MIPS:
4fe85591 12894 case EM_MIPS_RS3_LE:
252b5132
RH		 12895 return process_mips_specific (file);
12896 break;
34c8bcba
JM		 12897 case EM_PPC:
12898 return process_power_specific (file);
12899 break;
59e6276b
JM		 12900 case EM_TI_C6000:
12901 return process_tic6x_specific (file);
12902 break;
252b5132
RH		 12903 default:
12904 break;
12905 }
12906 return 1;
12907}
12908
12909static int
2cf0635d 12910get_file_header (FILE * file)
252b5132 12911{
9ea033b2
NC		 12912 /* Read in the identity array. */
12913 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 12914 return 0;
12915
9ea033b2 12916 /* Determine how to read the rest of the header. */
b34976b6 12917 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 12918 {
12919 default: /* fall through */
12920 case ELFDATANONE: /* fall through */
adab8cdc
AO		 12921 case ELFDATA2LSB:
12922 byte_get = byte_get_little_endian;
12923 byte_put = byte_put_little_endian;
12924 break;
12925 case ELFDATA2MSB:
12926 byte_get = byte_get_big_endian;
12927 byte_put = byte_put_big_endian;
12928 break;
9ea033b2
NC		 12929 }
12930
12931 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 12932 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 12933
12934 /* Read in the rest of the header. */
12935 if (is_32bit_elf)
12936 {
12937 Elf32_External_Ehdr ehdr32;
252b5132 12938
9ea033b2
NC		 12939 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12940 return 0;
103f02d3 12941
9ea033b2
NC		 12942 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12943 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12944 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12945 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12946 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12947 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12948 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12949 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12950 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12951 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12952 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12953 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12954 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12955 }
252b5132 12956 else
9ea033b2
NC		 12957 {
12958 Elf64_External_Ehdr ehdr64;
a952a375
NC		 12959
12960 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12961 we will not be able to cope with the 64bit data found in
12962 64 ELF files. Detect this now and abort before we start
50c2245b 12963 overwriting things. */
a952a375
NC		 12964 if (sizeof (bfd_vma) < 8)
12965 {
e3c8793a
NC		 12966 error (_("This instance of readelf has been built without support for a\n\
1296764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 12968 return 0;
12969 }
103f02d3 12970
9ea033b2
NC		 12971 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12972 return 0;
103f02d3 12973
9ea033b2
NC		 12974 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12975 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12976 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 12977 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12978 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12979 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 12980 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12981 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12982 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12983 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12984 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12985 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12986 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12987 }
252b5132 12988
7ece0d85
JJ		 12989 if (elf_header.e_shoff)
12990 {
12991 /* There may be some extensions in the first section header. Don't
12992 bomb if we can't read it. */
12993 if (is_32bit_elf)
12994 get_32bit_section_headers (file, 1);
12995 else
12996 get_64bit_section_headers (file, 1);
12997 }
560f3c1c 12998
252b5132
RH		 12999 return 1;
13000}
13001
fb52b2f4
NC		 13002/* Process one ELF object file according to the command line options.
13003 This file may actually be stored in an archive. The file is
13004 positioned at the start of the ELF object. */
13005
ff78d6d6 13006static int
2cf0635d 13007process_object (char * file_name, FILE * file)
252b5132 13008{
252b5132
RH		 13009 unsigned int i;
13010
252b5132
RH		 13011 if (! get_file_header (file))
13012 {
13013 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13014 return 1;
252b5132
RH		 13015 }
13016
13017 /* Initialise per file variables. */
60bca95a 13018 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13019 version_info[i] = 0;
13020
60bca95a 13021 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13022 dynamic_info[i] = 0;
5115b233 13023 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13024
13025 /* Process the file. */
13026 if (show_name)
13027 printf (_("\nFile: %s\n"), file_name);
13028
18bd398b
NC		 13029 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13030 Note we do this even if cmdline_dump_sects is empty because we
13031 must make sure that the dump_sets array is zeroed out before each
13032 object file is processed. */
13033 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13034 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13035
13036 if (num_cmdline_dump_sects > 0)
13037 {
13038 if (num_dump_sects == 0)
13039 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13040 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13041
13042 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13043 memcpy (dump_sects, cmdline_dump_sects,
13044 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13045 }
d70c5fc7 13046
252b5132 13047 if (! process_file_header ())
fb52b2f4 13048 return 1;
252b5132 13049
d1f5c6e3 13050 if (! process_section_headers (file))
2f62977e 13051 {
d1f5c6e3
L		 13052 /* Without loaded section headers we cannot process lots of
13053 things. */
2f62977e 13054 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13055
2f62977e 13056 if (! do_using_dynamic)
2c610e4b 13057 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13058 }
252b5132 13059
d1f5c6e3
L		 13060 if (! process_section_groups (file))
13061 {
13062 /* Without loaded section groups we cannot process unwind. */
13063 do_unwind = 0;
13064 }
13065
2f62977e 13066 if (process_program_headers (file))
b2d38a17 13067 process_dynamic_section (file);
252b5132
RH		 13068
13069 process_relocs (file);
13070
4d6ed7c8
NC		 13071 process_unwind (file);
13072
252b5132
RH		 13073 process_symbol_table (file);
13074
13075 process_syminfo (file);
13076
13077 process_version_sections (file);
13078
13079 process_section_contents (file);
f5842774 13080
1ec5cd37 13081 process_notes (file);
103f02d3 13082
047b2264
JJ		 13083 process_gnu_liblist (file);
13084
252b5132
RH		 13085 process_arch_specific (file);
13086
d93f0186
NC		 13087 if (program_headers)
13088 {
13089 free (program_headers);
13090 program_headers = NULL;
13091 }
13092
252b5132
RH		 13093 if (section_headers)
13094 {
13095 free (section_headers);
13096 section_headers = NULL;
13097 }
13098
13099 if (string_table)
13100 {
13101 free (string_table);
13102 string_table = NULL;
d40ac9bd 13103 string_table_length = 0;
252b5132
RH		 13104 }
13105
13106 if (dynamic_strings)
13107 {
13108 free (dynamic_strings);
13109 dynamic_strings = NULL;
d79b3d50 13110 dynamic_strings_length = 0;
252b5132
RH		 13111 }
13112
13113 if (dynamic_symbols)
13114 {
13115 free (dynamic_symbols);
13116 dynamic_symbols = NULL;
19936277 13117 num_dynamic_syms = 0;
252b5132
RH		 13118 }
13119
13120 if (dynamic_syminfo)
13121 {
13122 free (dynamic_syminfo);
13123 dynamic_syminfo = NULL;
13124 }
ff78d6d6 13125
293c573e
MR		 13126 if (dynamic_section)
13127 {
13128 free (dynamic_section);
13129 dynamic_section = NULL;
13130 }
13131
e4b17d5c
L		 13132 if (section_headers_groups)
13133 {
13134 free (section_headers_groups);
13135 section_headers_groups = NULL;
13136 }
13137
13138 if (section_groups)
13139 {
2cf0635d
NC		 13140 struct group_list * g;
13141 struct group_list * next;
e4b17d5c
L		 13142
13143 for (i = 0; i < group_count; i++)
13144 {
13145 for (g = section_groups [i].root; g != NULL; g = next)
13146 {
13147 next = g->next;
13148 free (g);
13149 }
13150 }
13151
13152 free (section_groups);
13153 section_groups = NULL;
13154 }
13155
19e6b90e 13156 free_debug_memory ();
18bd398b 13157
ff78d6d6 13158 return 0;
252b5132
RH		 13159}
13160
2cf0635d
NC		 13161/* Process an ELF archive.
13162 On entry the file is positioned just after the ARMAG string. */
13163
13164static int
13165process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13166{
13167 struct archive_info arch;
13168 struct archive_info nested_arch;
13169 size_t got;
2cf0635d
NC		 13170 int ret;
13171
13172 show_name = 1;
13173
13174 /* The ARCH structure is used to hold information about this archive. */
13175 arch.file_name = NULL;
13176 arch.file = NULL;
13177 arch.index_array = NULL;
13178 arch.sym_table = NULL;
13179 arch.longnames = NULL;
13180
13181 /* The NESTED_ARCH structure is used as a single-item cache of information
13182 about a nested archive (when members of a thin archive reside within
13183 another regular archive file). */
13184 nested_arch.file_name = NULL;
13185 nested_arch.file = NULL;
13186 nested_arch.index_array = NULL;
13187 nested_arch.sym_table = NULL;
13188 nested_arch.longnames = NULL;
13189
13190 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13191 {
13192 ret = 1;
13193 goto out;
4145f1d5 13194 }
fb52b2f4 13195
4145f1d5
NC		 13196 if (do_archive_index)
13197 {
2cf0635d 13198 if (arch.sym_table == NULL)
4145f1d5
NC		 13199 error (_("%s: unable to dump the index as none was found\n"), file_name);
13200 else
13201 {
2cf0635d 13202 unsigned int i, l;
4145f1d5
NC		 13203 unsigned long current_pos;
13204
13205 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
2cf0635d 13206 file_name, arch.index_num, arch.sym_size);
4145f1d5
NC		 13207 current_pos = ftell (file);
13208
2cf0635d 13209 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13210 {
2cf0635d
NC		 13211 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13212 {
13213 char * member_name;
4145f1d5 13214
2cf0635d
NC		 13215 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13216
13217 if (member_name != NULL)
13218 {
13219 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13220
13221 if (qualified_name != NULL)
13222 {
13223 printf (_("Binary %s contains:\n"), qualified_name);
13224 free (qualified_name);
13225 }
4145f1d5
NC		 13226 }
13227 }
2cf0635d
NC		 13228
13229 if (l >= arch.sym_size)
4145f1d5
NC		 13230 {
13231 error (_("%s: end of the symbol table reached before the end of the index\n"),
13232 file_name);
cb8f3167 13233 break;
4145f1d5 13234 }
2cf0635d
NC		 13235 printf ("\t%s\n", arch.sym_table + l);
13236 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13237 }
13238
2cf0635d
NC		 13239 if (l & 01)
13240 ++l;
13241 if (l < arch.sym_size)
4145f1d5
NC		 13242 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13243 file_name);
13244
4145f1d5
NC		 13245 if (fseek (file, current_pos, SEEK_SET) != 0)
13246 {
13247 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13248 ret = 1;
13249 goto out;
4145f1d5 13250 }
fb52b2f4 13251 }
4145f1d5
NC		 13252
13253 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13254 && !do_segments && !do_header && !do_dump && !do_version
13255 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13256 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13257 {
13258 ret = 0; /* Archive index only. */
13259 goto out;
13260 }
fb52b2f4
NC		 13261 }
13262
d989285c 13263 ret = 0;
fb52b2f4
NC		 13264
13265 while (1)
13266 {
2cf0635d
NC		 13267 char * name;
13268 size_t namelen;
13269 char * qualified_name;
13270
13271 /* Read the next archive header. */
13272 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13273 {
13274 error (_("%s: failed to seek to next archive header\n"), file_name);
13275 return 1;
13276 }
13277 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13278 if (got != sizeof arch.arhdr)
13279 {
13280 if (got == 0)
13281 break;
13282 error (_("%s: failed to read archive header\n"), file_name);
13283 ret = 1;
13284 break;
13285 }
13286 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13287 {
13288 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13289 ret = 1;
13290 break;
13291 }
13292
13293 arch.next_arhdr_offset += sizeof arch.arhdr;
13294
13295 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13296 if (archive_file_size & 01)
13297 ++archive_file_size;
13298
13299 name = get_archive_member_name (&arch, &nested_arch);
13300 if (name == NULL)
fb52b2f4 13301 {
0fd3a477 13302 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13303 ret = 1;
13304 break;
fb52b2f4 13305 }
2cf0635d 13306 namelen = strlen (name);
fb52b2f4 13307
2cf0635d
NC		 13308 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13309 if (qualified_name == NULL)
fb52b2f4 13310 {
2cf0635d 13311 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13312 ret = 1;
13313 break;
fb52b2f4
NC		 13314 }
13315
2cf0635d
NC		 13316 if (is_thin_archive && arch.nested_member_origin == 0)
13317 {
13318 /* This is a proxy for an external member of a thin archive. */
13319 FILE * member_file;
13320 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13321 if (member_file_name == NULL)
13322 {
13323 ret = 1;
13324 break;
13325 }
13326
13327 member_file = fopen (member_file_name, "rb");
13328 if (member_file == NULL)
13329 {
13330 error (_("Input file '%s' is not readable.\n"), member_file_name);
13331 free (member_file_name);
13332 ret = 1;
13333 break;
13334 }
13335
13336 archive_file_offset = arch.nested_member_origin;
13337
13338 ret |= process_object (qualified_name, member_file);
13339
13340 fclose (member_file);
13341 free (member_file_name);
13342 }
13343 else if (is_thin_archive)
13344 {
13345 /* This is a proxy for a member of a nested archive. */
13346 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13347
13348 /* The nested archive file will have been opened and setup by
13349 get_archive_member_name. */
13350 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13351 {
13352 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13353 ret = 1;
13354 break;
13355 }
13356
13357 ret |= process_object (qualified_name, nested_arch.file);
13358 }
13359 else
13360 {
13361 archive_file_offset = arch.next_arhdr_offset;
13362 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13363
2cf0635d
NC		 13364 ret |= process_object (qualified_name, file);
13365 }
fb52b2f4 13366
2b52916e
L		 13367 if (dump_sects != NULL)
13368 {
13369 free (dump_sects);
13370 dump_sects = NULL;
13371 num_dump_sects = 0;
13372 }
13373
2cf0635d 13374 free (qualified_name);
fb52b2f4
NC		 13375 }
13376
4145f1d5 13377 out:
2cf0635d
NC		 13378 if (nested_arch.file != NULL)
13379 fclose (nested_arch.file);
13380 release_archive (&nested_arch);
13381 release_archive (&arch);
fb52b2f4 13382
d989285c 13383 return ret;
fb52b2f4
NC		 13384}
13385
13386static int
2cf0635d 13387process_file (char * file_name)
fb52b2f4 13388{
2cf0635d 13389 FILE * file;
fb52b2f4
NC		 13390 struct stat statbuf;
13391 char armag[SARMAG];
13392 int ret;
13393
13394 if (stat (file_name, &statbuf) < 0)
13395 {
f24ddbdd
NC		 13396 if (errno == ENOENT)
13397 error (_("'%s': No such file\n"), file_name);
13398 else
13399 error (_("Could not locate '%s'. System error message: %s\n"),
13400 file_name, strerror (errno));
13401 return 1;
13402 }
13403
13404 if (! S_ISREG (statbuf.st_mode))
13405 {
13406 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13407 return 1;
13408 }
13409
13410 file = fopen (file_name, "rb");
13411 if (file == NULL)
13412 {
f24ddbdd 13413 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13414 return 1;
13415 }
13416
13417 if (fread (armag, SARMAG, 1, file) != 1)
13418 {
4145f1d5 13419 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13420 fclose (file);
13421 return 1;
13422 }
13423
13424 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13425 ret = process_archive (file_name, file, FALSE);
13426 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13427 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13428 else
13429 {
4145f1d5
NC		 13430 if (do_archive_index)
13431 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13432 file_name);
13433
fb52b2f4
NC		 13434 rewind (file);
13435 archive_file_size = archive_file_offset = 0;
13436 ret = process_object (file_name, file);
13437 }
13438
13439 fclose (file);
13440
13441 return ret;
13442}
13443
252b5132
RH		 13444#ifdef SUPPORT_DISASSEMBLY
13445/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13446 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13447 symbols. */
252b5132
RH		 13448
13449void
2cf0635d 13450print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13451{
13452 fprintf (outfile,"0x%8.8x", addr);
13453}
13454
e3c8793a 13455/* Needed by the i386 disassembler. */
252b5132
RH		 13456void
13457db_task_printsym (unsigned int addr)
13458{
13459 print_address (addr, stderr);
13460}
13461#endif
13462
13463int
2cf0635d 13464main (int argc, char ** argv)
252b5132 13465{
ff78d6d6
L		 13466 int err;
13467
252b5132
RH		 13468#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13469 setlocale (LC_MESSAGES, "");
3882b010
L		 13470#endif
13471#if defined (HAVE_SETLOCALE)
13472 setlocale (LC_CTYPE, "");
252b5132
RH		 13473#endif
13474 bindtextdomain (PACKAGE, LOCALEDIR);
13475 textdomain (PACKAGE);
13476
869b9d07
MM		 13477 expandargv (&argc, &argv);
13478
252b5132
RH		 13479 parse_args (argc, argv);
13480
18bd398b 13481 if (num_dump_sects > 0)
59f14fc0 13482 {
18bd398b 13483 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13484 cmdline_dump_sects = (dump_type *)
13485 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13486 if (cmdline_dump_sects == NULL)
591a748a 13487 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13488 else
13489 {
09c11c86
NC		 13490 memcpy (cmdline_dump_sects, dump_sects,
13491 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13492 num_cmdline_dump_sects = num_dump_sects;
13493 }
13494 }
13495
18bd398b
NC		 13496 if (optind < (argc - 1))
13497 show_name = 1;
13498
ff78d6d6 13499 err = 0;
252b5132 13500 while (optind < argc)
18bd398b 13501 err |= process_file (argv[optind++]);
252b5132
RH		 13502
13503 if (dump_sects != NULL)
13504 free (dump_sects);
59f14fc0
AS		 13505 if (cmdline_dump_sects != NULL)
13506 free (cmdline_dump_sects);
252b5132 13507
ff78d6d6 13508 return err;
252b5132 13509}
Empty description
This page took 3.584485 seconds and 4 git commands to generate.