]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6e3d6dc1 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
8b971f9f 3 2008, 2009, 2010, 2011, 2012
a0f19280 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 7 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
32866df7 13 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
b43b5d5f
NC		 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
252b5132 25\f
9eb20dd8 26/* The difference between readelf and objdump:
252b5132 27
74013231 28 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 29 so why does the binutils project have two file dumpers ?
0de14b54 30
9eb20dd8
NC		 31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44\f
3db64b00 45#include "sysdep.h"
252b5132 46#include <assert.h>
252b5132 47#include <time.h>
1b315056
CS		 48#ifdef HAVE_ZLIB_H
49#include <zlib.h>
50#endif
7bfd842d 51#include <wchar.h>
252b5132 52
a952a375 53#if __GNUC__ >= 2
19936277 54/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 55 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 56 Only do this if we believe that the compiler can support a 64 bit
a952a375 57 data type. For now we only rely on GCC being able to do this. */
19936277 58#define BFD64
a952a375
NC		 59#endif
60
3db64b00
AM		 61#include "bfd.h"
62#include "bucomm.h"
3284fe0c 63#include "elfcomm.h"
19e6b90e 64#include "dwarf.h"
252b5132
RH		 65
66#include "elf/common.h"
67#include "elf/external.h"
68#include "elf/internal.h"
252b5132 69
4b78141a
NC		 70
71/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76#include "elf/h8.h"
77#undef _ELF_H8_H
78
79/* Undo the effects of #including reloc-macros.h. */
80
81#undef START_RELOC_NUMBERS
82#undef RELOC_NUMBER
83#undef FAKE_RELOC
84#undef EMPTY_RELOC
85#undef END_RELOC_NUMBERS
86#undef _RELOC_MACROS_H
87
252b5132
RH		 88/* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92#define RELOC_MACROS_GEN_FUNC
93
a06ea964 94#include "elf/aarch64.h"
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"
cfb8c092 106#include "elf/epiphany.h"
252b5132 107#include "elf/fr30.h"
5c70f934 108#include "elf/frv.h"
3b16e843
NC		 109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
35b1837e 112#include "elf/i370.h"
3b16e843
NC		 113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
1e4cf259 116#include "elf/ip2k.h"
84e94c90 117#include "elf/lm32.h"
1c0d3aa6 118#include "elf/iq2000.h"
49f58d10 119#include "elf/m32c.h"
3b16e843
NC		 120#include "elf/m32r.h"
121#include "elf/m68k.h"
75751cd9 122#include "elf/m68hc11.h"
252b5132 123#include "elf/mcore.h"
15ab5209 124#include "elf/mep.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
3b16e843 133#include "elf/or32.h"
7d466069 134#include "elf/pj.h"
3b16e843 135#include "elf/ppc.h"
c833c019 136#include "elf/ppc64.h"
99c513f6 137#include "elf/rl78.h"
c7927a3c 138#include "elf/rx.h"
a85d7ed0 139#include "elf/s390.h"
1c0d3aa6 140#include "elf/score.h"
3b16e843
NC		 141#include "elf/sh.h"
142#include "elf/sparc.h"
e9f53129 143#include "elf/spu.h"
40b36596 144#include "elf/tic6x.h"
aa137e4d
NC		 145#include "elf/tilegx.h"
146#include "elf/tilepro.h"
3b16e843 147#include "elf/v850.h"
179d3252 148#include "elf/vax.h"
3b16e843 149#include "elf/x86-64.h"
c29aca4a 150#include "elf/xc16x.h"
f6c1a2d5 151#include "elf/xgate.h"
93fbbb04 152#include "elf/xstormy16.h"
88da6820 153#include "elf/xtensa.h"
252b5132 154
252b5132 155#include "getopt.h"
566b0d53 156#include "libiberty.h"
09c11c86 157#include "safe-ctype.h"
2cf0635d 158#include "filenames.h"
252b5132 159
2cf0635d 160char * program_name = "readelf";
85b1c36d
BE		 161static long archive_file_offset;
162static unsigned long archive_file_size;
163static unsigned long dynamic_addr;
164static bfd_size_type dynamic_size;
165static unsigned int dynamic_nent;
2cf0635d 166static char * dynamic_strings;
85b1c36d 167static unsigned long dynamic_strings_length;
2cf0635d 168static char * string_table;
85b1c36d
BE		 169static unsigned long string_table_length;
170static unsigned long num_dynamic_syms;
2cf0635d
NC		 171static Elf_Internal_Sym * dynamic_symbols;
172static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 173static unsigned long dynamic_syminfo_offset;
174static unsigned int dynamic_syminfo_nent;
f8eae8b2 175static char program_interpreter[PATH_MAX];
bb8a0291 176static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 177static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 178static bfd_vma version_info[16];
179static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 180static Elf_Internal_Shdr * section_headers;
181static Elf_Internal_Phdr * program_headers;
182static Elf_Internal_Dyn * dynamic_section;
183static Elf_Internal_Shdr * symtab_shndx_hdr;
85b1c36d
BE		 184static int show_name;
185static int do_dynamic;
186static int do_syms;
2c610e4b 187static int do_dyn_syms;
85b1c36d
BE		 188static int do_reloc;
189static int do_sections;
190static int do_section_groups;
5477e8a0 191static int do_section_details;
85b1c36d
BE		 192static int do_segments;
193static int do_unwind;
194static int do_using_dynamic;
195static int do_header;
196static int do_dump;
197static int do_version;
85b1c36d
BE		 198static int do_histogram;
199static int do_debugging;
85b1c36d
BE		 200static int do_arch;
201static int do_notes;
4145f1d5 202static int do_archive_index;
85b1c36d 203static int is_32bit_elf;
252b5132 204
e4b17d5c
L		 205struct group_list
206{
2cf0635d 207 struct group_list * next;
e4b17d5c
L		 208 unsigned int section_index;
209};
210
211struct group
212{
2cf0635d 213 struct group_list * root;
e4b17d5c
L		 214 unsigned int group_index;
215};
216
85b1c36d 217static size_t group_count;
2cf0635d
NC		 218static struct group * section_groups;
219static struct group ** section_headers_groups;
e4b17d5c 220
09c11c86
NC		 221
222/* Flag bits indicating particular types of dump. */
223#define HEX_DUMP (1 << 0) /* The -x command line switch. */
224#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
225#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
226#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 227#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 228
229typedef unsigned char dump_type;
230
231/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 232struct dump_list_entry
233{
2cf0635d 234 char * name;
09c11c86 235 dump_type type;
2cf0635d 236 struct dump_list_entry * next;
aef1f6d0 237};
2cf0635d 238static struct dump_list_entry * dump_sects_byname;
aef1f6d0 239
09c11c86
NC		 240/* A dynamic array of flags indicating for which sections a dump
241 has been requested via command line switches. */
242static dump_type * cmdline_dump_sects = NULL;
243static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 244
245/* A dynamic array of flags indicating for which sections a dump of
246 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 247 basis and then initialised from the cmdline_dump_sects array,
248 the results of interpreting the -w switch, and the
249 dump_sects_byname list. */
09c11c86
NC		 250static dump_type * dump_sects = NULL;
251static unsigned int num_dump_sects = 0;
252b5132 252
252b5132 253
c256ffe7 254/* How to print a vma value. */
843dd992
NC		 255typedef enum print_mode
256{
257 HEX,
258 DEC,
259 DEC_5,
260 UNSIGNED,
261 PREFIX_HEX,
262 FULL_HEX,
263 LONG_HEX
264}
265print_mode;
266
9c19a809
NC		 267#define UNKNOWN -1
268
2b692964
NC		 269#define SECTION_NAME(X) \
270 ((X) == NULL ? _("<none>") \
271 : string_table == NULL ? _("<no-name>") \
272 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 273 : string_table + (X)->sh_name))
252b5132 274
ee42cf8c 275#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 276
ba5cdace
NC		 277#define GET_ELF_SYMBOLS(file, section, sym_count) \
278 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
279 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 280
d79b3d50
NC		 281#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
282/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
283 already been called and verified that the string exists. */
284#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 285
61865e30
NC		 286#define REMOVE_ARCH_BITS(ADDR) \
287 do \
288 { \
289 if (elf_header.e_machine == EM_ARM) \
290 (ADDR) &= ~1; \
291 } \
292 while (0)
d79b3d50 293\f
59245841
NC		 294/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
295 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
296 using malloc and fill that. In either case return the pointer to the start of
297 the retrieved data or NULL if something went wrong. If something does go wrong
298 emit an error message using REASON as part of the context. */
299
c256ffe7 300static void *
2cf0635d
NC		 301get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
302 const char * reason)
a6e9f9df 303{
2cf0635d 304 void * mvar;
a6e9f9df 305
c256ffe7 306 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 307 return NULL;
308
fb52b2f4 309 if (fseek (file, archive_file_offset + offset, SEEK_SET))
a6e9f9df 310 {
0fd3a477 311 error (_("Unable to seek to 0x%lx for %s\n"),
0af1713e 312 (unsigned long) archive_file_offset + offset, reason);
a6e9f9df
AM		 313 return NULL;
314 }
315
316 mvar = var;
317 if (mvar == NULL)
318 {
c256ffe7
JJ		 319 /* Check for overflow. */
320 if (nmemb < (~(size_t) 0 - 1) / size)
321 /* + 1 so that we can '\0' terminate invalid string table sections. */
322 mvar = malloc (size * nmemb + 1);
a6e9f9df
AM		 323
324 if (mvar == NULL)
325 {
0fd3a477
JW		 326 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
327 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 328 return NULL;
329 }
c256ffe7
JJ		 330
331 ((char *) mvar)[size * nmemb] = '\0';
a6e9f9df
AM		 332 }
333
c256ffe7 334 if (fread (mvar, size, nmemb, file) != nmemb)
a6e9f9df 335 {
0fd3a477
JW		 336 error (_("Unable to read in 0x%lx bytes of %s\n"),
337 (unsigned long)(size * nmemb), reason);
a6e9f9df
AM		 338 if (mvar != var)
339 free (mvar);
340 return NULL;
341 }
342
343 return mvar;
344}
345
14a91970 346/* Print a VMA value. */
cb8f3167 347
66543521 348static int
14a91970 349print_vma (bfd_vma vma, print_mode mode)
66543521 350{
66543521
AM		 351 int nc = 0;
352
14a91970 353 switch (mode)
66543521 354 {
14a91970
AM		 355 case FULL_HEX:
356 nc = printf ("0x");
357 /* Drop through. */
66543521 358
14a91970 359 case LONG_HEX:
f7a99963 360#ifdef BFD64
14a91970 361 if (is_32bit_elf)
437c2fb7 362 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 363#endif
14a91970
AM		 364 printf_vma (vma);
365 return nc + 16;
b19aac67 366
14a91970
AM		 367 case DEC_5:
368 if (vma <= 99999)
369 return printf ("%5" BFD_VMA_FMT "d", vma);
370 /* Drop through. */
66543521 371
14a91970
AM		 372 case PREFIX_HEX:
373 nc = printf ("0x");
374 /* Drop through. */
66543521 375
14a91970
AM		 376 case HEX:
377 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 378
14a91970
AM		 379 case DEC:
380 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 381
14a91970
AM		 382 case UNSIGNED:
383 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 384 }
66543521 385 return 0;
f7a99963
NC		 386}
387
7bfd842d
NC		 388/* Display a symbol on stdout. Handles the display of control characters and
389 multibye characters.
31104126 390
7bfd842d
NC		 391 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
392
393 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
394 padding as necessary.
171191ba
NC		 395
396 Returns the number of emitted characters. */
397
398static unsigned int
7a88bc9c 399print_symbol (int width, const char *symbol)
31104126 400{
171191ba 401 bfd_boolean extra_padding = FALSE;
7bfd842d
NC		 402 int num_printed = 0;
403 mbstate_t state;
404 int width_remaining;
961c521f 405
7bfd842d 406 if (width < 0)
961c521f 407 {
961c521f
NC		 408 /* Keep the width positive. This also helps. */
409 width = - width;
171191ba 410 extra_padding = TRUE;
7bfd842d 411 }
961c521f 412
7bfd842d
NC		 413 if (do_wide)
414 /* Set the remaining width to a very large value.
415 This simplifies the code below. */
416 width_remaining = INT_MAX;
417 else
418 width_remaining = width;
cb8f3167 419
7bfd842d
NC		 420 /* Initialise the multibyte conversion state. */
421 memset (& state, 0, sizeof (state));
961c521f 422
7bfd842d
NC		 423 while (width_remaining)
424 {
425 size_t n;
426 wchar_t w;
427 const char c = *symbol++;
961c521f 428
7bfd842d 429 if (c == 0)
961c521f
NC		 430 break;
431
7bfd842d
NC		 432 /* Do not print control characters directly as they can affect terminal
433 settings. Such characters usually appear in the names generated
434 by the assembler for local labels. */
435 if (ISCNTRL (c))
961c521f 436 {
7bfd842d 437 if (width_remaining < 2)
961c521f
NC		 438 break;
439
7bfd842d
NC		 440 printf ("^%c", c + 0x40);
441 width_remaining -= 2;
171191ba 442 num_printed += 2;
961c521f 443 }
7bfd842d
NC		 444 else if (ISPRINT (c))
445 {
446 putchar (c);
447 width_remaining --;
448 num_printed ++;
449 }
961c521f
NC		 450 else
451 {
7bfd842d
NC		 452 /* Let printf do the hard work of displaying multibyte characters. */
453 printf ("%.1s", symbol - 1);
454 width_remaining --;
455 num_printed ++;
456
457 /* Try to find out how many bytes made up the character that was
458 just printed. Advance the symbol pointer past the bytes that
459 were displayed. */
460 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
461 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
462 symbol += (n - 1);
961c521f 463 }
961c521f 464 }
171191ba 465
7bfd842d 466 if (extra_padding && num_printed < width)
171191ba
NC		 467 {
468 /* Fill in the remaining spaces. */
7bfd842d
NC		 469 printf ("%-*s", width - num_printed, " ");
470 num_printed = width;
171191ba
NC		 471 }
472
473 return num_printed;
31104126
NC		 474}
475
89fac5e3
RS		 476/* Return a pointer to section NAME, or NULL if no such section exists. */
477
478static Elf_Internal_Shdr *
2cf0635d 479find_section (const char * name)
89fac5e3
RS		 480{
481 unsigned int i;
482
483 for (i = 0; i < elf_header.e_shnum; i++)
484 if (streq (SECTION_NAME (section_headers + i), name))
485 return section_headers + i;
486
487 return NULL;
488}
489
0b6ae522
DJ		 490/* Return a pointer to a section containing ADDR, or NULL if no such
491 section exists. */
492
493static Elf_Internal_Shdr *
494find_section_by_address (bfd_vma addr)
495{
496 unsigned int i;
497
498 for (i = 0; i < elf_header.e_shnum; i++)
499 {
500 Elf_Internal_Shdr *sec = section_headers + i;
501 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
502 return sec;
503 }
504
505 return NULL;
506}
507
508/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
509 bytes read. */
510
511static unsigned long
512read_uleb128 (unsigned char *data, unsigned int *length_return)
513{
514 return read_leb128 (data, length_return, 0);
515}
516
28f997cf
TG		 517/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
518 This OS has so many departures from the ELF standard that we test it at
519 many places. */
520
521static inline int
522is_ia64_vms (void)
523{
524 return elf_header.e_machine == EM_IA_64
525 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
526}
527
bcedfee6 528/* Guess the relocation size commonly used by the specific machines. */
252b5132 529
252b5132 530static int
2dc4cec1 531guess_is_rela (unsigned int e_machine)
252b5132 532{
9c19a809 533 switch (e_machine)
252b5132
RH		 534 {
535 /* Targets that use REL relocations. */
252b5132
RH		 536 case EM_386:
537 case EM_486:
63fcb9e9 538 case EM_960:
e9f53129 539 case EM_ARM:
2b0337b0 540 case EM_D10V:
252b5132 541 case EM_CYGNUS_D10V:
e9f53129 542 case EM_DLX:
252b5132 543 case EM_MIPS:
4fe85591 544 case EM_MIPS_RS3_LE:
e9f53129
AM		 545 case EM_CYGNUS_M32R:
546 case EM_OPENRISC:
547 case EM_OR32:
1c0d3aa6 548 case EM_SCORE:
f6c1a2d5 549 case EM_XGATE:
9c19a809 550 return FALSE;
103f02d3 551
252b5132
RH		 552 /* Targets that use RELA relocations. */
553 case EM_68K:
e9f53129 554 case EM_860:
a06ea964 555 case EM_AARCH64:
cfb8c092 556 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 557 case EM_ALPHA:
558 case EM_ALTERA_NIOS2:
559 case EM_AVR:
560 case EM_AVR_OLD:
561 case EM_BLACKFIN:
60bca95a 562 case EM_CR16:
e9f53129
AM		 563 case EM_CRIS:
564 case EM_CRX:
2b0337b0 565 case EM_D30V:
252b5132 566 case EM_CYGNUS_D30V:
2b0337b0 567 case EM_FR30:
252b5132 568 case EM_CYGNUS_FR30:
5c70f934 569 case EM_CYGNUS_FRV:
e9f53129
AM		 570 case EM_H8S:
571 case EM_H8_300:
572 case EM_H8_300H:
800eeca4 573 case EM_IA_64:
1e4cf259
NC		 574 case EM_IP2K:
575 case EM_IP2K_OLD:
3b36097d 576 case EM_IQ2000:
84e94c90 577 case EM_LATTICEMICO32:
ff7eeb89 578 case EM_M32C_OLD:
49f58d10 579 case EM_M32C:
e9f53129
AM		 580 case EM_M32R:
581 case EM_MCORE:
15ab5209 582 case EM_CYGNUS_MEP:
e9f53129
AM		 583 case EM_MMIX:
584 case EM_MN10200:
585 case EM_CYGNUS_MN10200:
586 case EM_MN10300:
587 case EM_CYGNUS_MN10300:
5506d11a 588 case EM_MOXIE:
e9f53129
AM		 589 case EM_MSP430:
590 case EM_MSP430_OLD:
d031aafb 591 case EM_MT:
64fd6348 592 case EM_NIOS32:
e9f53129
AM		 593 case EM_PPC64:
594 case EM_PPC:
99c513f6 595 case EM_RL78:
c7927a3c 596 case EM_RX:
e9f53129
AM		 597 case EM_S390:
598 case EM_S390_OLD:
599 case EM_SH:
600 case EM_SPARC:
601 case EM_SPARC32PLUS:
602 case EM_SPARCV9:
603 case EM_SPU:
40b36596 604 case EM_TI_C6000:
aa137e4d
NC		 605 case EM_TILEGX:
606 case EM_TILEPRO:
e9f53129
AM		 607 case EM_V850:
608 case EM_CYGNUS_V850:
609 case EM_VAX:
610 case EM_X86_64:
8a9036a4 611 case EM_L1OM:
7a9068fe 612 case EM_K1OM:
e9f53129
AM		 613 case EM_XSTORMY16:
614 case EM_XTENSA:
615 case EM_XTENSA_OLD:
7ba29e2a
NC		 616 case EM_MICROBLAZE:
617 case EM_MICROBLAZE_OLD:
9c19a809 618 return TRUE;
103f02d3 619
e9f53129
AM		 620 case EM_68HC05:
621 case EM_68HC08:
622 case EM_68HC11:
623 case EM_68HC16:
624 case EM_FX66:
625 case EM_ME16:
d1133906 626 case EM_MMA:
d1133906
NC		 627 case EM_NCPU:
628 case EM_NDR1:
e9f53129 629 case EM_PCP:
d1133906 630 case EM_ST100:
e9f53129 631 case EM_ST19:
d1133906 632 case EM_ST7:
e9f53129
AM		 633 case EM_ST9PLUS:
634 case EM_STARCORE:
d1133906 635 case EM_SVX:
e9f53129 636 case EM_TINYJ:
9c19a809
NC		 637 default:
638 warn (_("Don't know about relocations on this machine architecture\n"));
639 return FALSE;
640 }
641}
252b5132 642
9c19a809 643static int
2cf0635d 644slurp_rela_relocs (FILE * file,
d3ba0551
AM		 645 unsigned long rel_offset,
646 unsigned long rel_size,
2cf0635d
NC		 647 Elf_Internal_Rela ** relasp,
648 unsigned long * nrelasp)
9c19a809 649{
2cf0635d 650 Elf_Internal_Rela * relas;
4d6ed7c8
NC		 651 unsigned long nrelas;
652 unsigned int i;
252b5132 653
4d6ed7c8
NC		 654 if (is_32bit_elf)
655 {
2cf0635d 656 Elf32_External_Rela * erelas;
103f02d3 657
3f5e193b 658 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 659 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 660 if (!erelas)
661 return 0;
252b5132 662
4d6ed7c8 663 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 664
3f5e193b
NC		 665 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
666 sizeof (Elf_Internal_Rela));
103f02d3 667
4d6ed7c8
NC		 668 if (relas == NULL)
669 {
c256ffe7 670 free (erelas);
591a748a 671 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 672 return 0;
673 }
103f02d3 674
4d6ed7c8
NC		 675 for (i = 0; i < nrelas; i++)
676 {
677 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
678 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 679 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 680 }
103f02d3 681
4d6ed7c8
NC		 682 free (erelas);
683 }
684 else
685 {
2cf0635d 686 Elf64_External_Rela * erelas;
103f02d3 687
3f5e193b 688 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 689 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 690 if (!erelas)
691 return 0;
4d6ed7c8
NC		 692
693 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 694
3f5e193b
NC		 695 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
696 sizeof (Elf_Internal_Rela));
103f02d3 697
4d6ed7c8
NC		 698 if (relas == NULL)
699 {
c256ffe7 700 free (erelas);
591a748a 701 error (_("out of memory parsing relocs\n"));
4d6ed7c8 702 return 0;
9c19a809 703 }
4d6ed7c8
NC		 704
705 for (i = 0; i < nrelas; i++)
9c19a809 706 {
66543521
AM		 707 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
708 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 709 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 710
711 /* The #ifdef BFD64 below is to prevent a compile time
712 warning. We know that if we do not have a 64 bit data
713 type that we will never execute this code anyway. */
714#ifdef BFD64
715 if (elf_header.e_machine == EM_MIPS
716 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
717 {
718 /* In little-endian objects, r_info isn't really a
719 64-bit little-endian value: it has a 32-bit
720 little-endian symbol index followed by four
721 individual byte fields. Reorder INFO
722 accordingly. */
91d6fa6a
NC		 723 bfd_vma inf = relas[i].r_info;
724 inf = (((inf & 0xffffffff) << 32)
725 | ((inf >> 56) & 0xff)
726 | ((inf >> 40) & 0xff00)
727 | ((inf >> 24) & 0xff0000)
728 | ((inf >> 8) & 0xff000000));
729 relas[i].r_info = inf;
861fb55a
DJ		 730 }
731#endif /* BFD64 */
4d6ed7c8 732 }
103f02d3 733
4d6ed7c8
NC		 734 free (erelas);
735 }
736 *relasp = relas;
737 *nrelasp = nrelas;
738 return 1;
739}
103f02d3 740
4d6ed7c8 741static int
2cf0635d 742slurp_rel_relocs (FILE * file,
d3ba0551
AM		 743 unsigned long rel_offset,
744 unsigned long rel_size,
2cf0635d
NC		 745 Elf_Internal_Rela ** relsp,
746 unsigned long * nrelsp)
4d6ed7c8 747{
2cf0635d 748 Elf_Internal_Rela * rels;
4d6ed7c8
NC		 749 unsigned long nrels;
750 unsigned int i;
103f02d3 751
4d6ed7c8
NC		 752 if (is_32bit_elf)
753 {
2cf0635d 754 Elf32_External_Rel * erels;
103f02d3 755
3f5e193b 756 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 757 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 758 if (!erels)
759 return 0;
103f02d3 760
4d6ed7c8 761 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 762
3f5e193b 763 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 764
4d6ed7c8
NC		 765 if (rels == NULL)
766 {
c256ffe7 767 free (erels);
591a748a 768 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 769 return 0;
770 }
771
772 for (i = 0; i < nrels; i++)
773 {
774 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
775 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 776 rels[i].r_addend = 0;
9ea033b2 777 }
4d6ed7c8
NC		 778
779 free (erels);
9c19a809
NC		 780 }
781 else
782 {
2cf0635d 783 Elf64_External_Rel * erels;
9ea033b2 784
3f5e193b 785 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 786 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 787 if (!erels)
788 return 0;
103f02d3 789
4d6ed7c8 790 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 791
3f5e193b 792 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 793
4d6ed7c8 794 if (rels == NULL)
9c19a809 795 {
c256ffe7 796 free (erels);
591a748a 797 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 798 return 0;
799 }
103f02d3 800
4d6ed7c8
NC		 801 for (i = 0; i < nrels; i++)
802 {
66543521
AM		 803 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
804 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 805 rels[i].r_addend = 0;
861fb55a
DJ		 806
807 /* The #ifdef BFD64 below is to prevent a compile time
808 warning. We know that if we do not have a 64 bit data
809 type that we will never execute this code anyway. */
810#ifdef BFD64
811 if (elf_header.e_machine == EM_MIPS
812 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
813 {
814 /* In little-endian objects, r_info isn't really a
815 64-bit little-endian value: it has a 32-bit
816 little-endian symbol index followed by four
817 individual byte fields. Reorder INFO
818 accordingly. */
91d6fa6a
NC		 819 bfd_vma inf = rels[i].r_info;
820 inf = (((inf & 0xffffffff) << 32)
821 | ((inf >> 56) & 0xff)
822 | ((inf >> 40) & 0xff00)
823 | ((inf >> 24) & 0xff0000)
824 | ((inf >> 8) & 0xff000000));
825 rels[i].r_info = inf;
861fb55a
DJ		 826 }
827#endif /* BFD64 */
4d6ed7c8 828 }
103f02d3 829
4d6ed7c8
NC		 830 free (erels);
831 }
832 *relsp = rels;
833 *nrelsp = nrels;
834 return 1;
835}
103f02d3 836
aca88567
NC		 837/* Returns the reloc type extracted from the reloc info field. */
838
839static unsigned int
840get_reloc_type (bfd_vma reloc_info)
841{
842 if (is_32bit_elf)
843 return ELF32_R_TYPE (reloc_info);
844
845 switch (elf_header.e_machine)
846 {
847 case EM_MIPS:
848 /* Note: We assume that reloc_info has already been adjusted for us. */
849 return ELF64_MIPS_R_TYPE (reloc_info);
850
851 case EM_SPARCV9:
852 return ELF64_R_TYPE_ID (reloc_info);
853
854 default:
855 return ELF64_R_TYPE (reloc_info);
856 }
857}
858
859/* Return the symbol index extracted from the reloc info field. */
860
861static bfd_vma
862get_reloc_symindex (bfd_vma reloc_info)
863{
864 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
865}
866
d3ba0551
AM		 867/* Display the contents of the relocation data found at the specified
868 offset. */
ee42cf8c 869
41e92641 870static void
2cf0635d 871dump_relocations (FILE * file,
d3ba0551
AM		 872 unsigned long rel_offset,
873 unsigned long rel_size,
2cf0635d 874 Elf_Internal_Sym * symtab,
d3ba0551 875 unsigned long nsyms,
2cf0635d 876 char * strtab,
d79b3d50 877 unsigned long strtablen,
d3ba0551 878 int is_rela)
4d6ed7c8 879{
b34976b6 880 unsigned int i;
2cf0635d 881 Elf_Internal_Rela * rels;
103f02d3 882
4d6ed7c8
NC		 883 if (is_rela == UNKNOWN)
884 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 885
4d6ed7c8
NC		 886 if (is_rela)
887 {
c8286bd1 888 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 889 return;
4d6ed7c8
NC		 890 }
891 else
892 {
893 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 894 return;
252b5132
RH		 895 }
896
410f7a12
L		 897 if (is_32bit_elf)
898 {
899 if (is_rela)
2c71103e
NC		 900 {
901 if (do_wide)
902 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
903 else
904 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
905 }
410f7a12 906 else
2c71103e
NC		 907 {
908 if (do_wide)
909 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
910 else
911 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
912 }
410f7a12 913 }
252b5132 914 else
410f7a12
L		 915 {
916 if (is_rela)
2c71103e
NC		 917 {
918 if (do_wide)
8beeaeb7 919 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 920 else
921 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
922 }
410f7a12 923 else
2c71103e
NC		 924 {
925 if (do_wide)
8beeaeb7 926 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 927 else
928 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
929 }
410f7a12 930 }
252b5132
RH		 931
932 for (i = 0; i < rel_size; i++)
933 {
2cf0635d 934 const char * rtype;
b34976b6 935 bfd_vma offset;
91d6fa6a 936 bfd_vma inf;
b34976b6
AM		 937 bfd_vma symtab_index;
938 bfd_vma type;
103f02d3 939
b34976b6 940 offset = rels[i].r_offset;
91d6fa6a 941 inf = rels[i].r_info;
103f02d3 942
91d6fa6a
NC		 943 type = get_reloc_type (inf);
944 symtab_index = get_reloc_symindex (inf);
252b5132 945
410f7a12
L		 946 if (is_32bit_elf)
947 {
39dbeff8
AM		 948 printf ("%8.8lx %8.8lx ",
949 (unsigned long) offset & 0xffffffff,
91d6fa6a 950 (unsigned long) inf & 0xffffffff);
410f7a12
L		 951 }
952 else
953 {
39dbeff8
AM		 954#if BFD_HOST_64BIT_LONG
955 printf (do_wide
956 ? "%16.16lx %16.16lx "
957 : "%12.12lx %12.12lx ",
91d6fa6a 958 offset, inf);
39dbeff8 959#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 960#ifndef __MSVCRT__
39dbeff8
AM		 961 printf (do_wide
962 ? "%16.16llx %16.16llx "
963 : "%12.12llx %12.12llx ",
91d6fa6a 964 offset, inf);
6e3d6dc1
NC		 965#else
966 printf (do_wide
967 ? "%16.16I64x %16.16I64x "
968 : "%12.12I64x %12.12I64x ",
91d6fa6a 969 offset, inf);
6e3d6dc1 970#endif
39dbeff8 971#else
2c71103e
NC		 972 printf (do_wide
973 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
974 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 975 _bfd_int64_high (offset),
976 _bfd_int64_low (offset),
91d6fa6a
NC		 977 _bfd_int64_high (inf),
978 _bfd_int64_low (inf));
9ea033b2 979#endif
410f7a12 980 }
103f02d3 981
252b5132
RH		 982 switch (elf_header.e_machine)
983 {
984 default:
985 rtype = NULL;
986 break;
987
a06ea964
NC		 988 case EM_AARCH64:
989 rtype = elf_aarch64_reloc_type (type);
990 break;
991
2b0337b0 992 case EM_M32R:
252b5132 993 case EM_CYGNUS_M32R:
9ea033b2 994 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 995 break;
996
997 case EM_386:
998 case EM_486:
9ea033b2 999 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1000 break;
1001
ba2685cc
AM		 1002 case EM_68HC11:
1003 case EM_68HC12:
1004 rtype = elf_m68hc11_reloc_type (type);
1005 break;
75751cd9 1006
252b5132 1007 case EM_68K:
9ea033b2 1008 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1009 break;
1010
63fcb9e9 1011 case EM_960:
9ea033b2 1012 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1013 break;
1014
adde6300 1015 case EM_AVR:
2b0337b0 1016 case EM_AVR_OLD:
adde6300
AM		 1017 rtype = elf_avr_reloc_type (type);
1018 break;
1019
9ea033b2
NC		 1020 case EM_OLD_SPARCV9:
1021 case EM_SPARC32PLUS:
1022 case EM_SPARCV9:
252b5132 1023 case EM_SPARC:
9ea033b2 1024 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1025 break;
1026
e9f53129
AM		 1027 case EM_SPU:
1028 rtype = elf_spu_reloc_type (type);
1029 break;
1030
2b0337b0 1031 case EM_V850:
252b5132 1032 case EM_CYGNUS_V850:
9ea033b2 1033 rtype = v850_reloc_type (type);
252b5132
RH		 1034 break;
1035
2b0337b0 1036 case EM_D10V:
252b5132 1037 case EM_CYGNUS_D10V:
9ea033b2 1038 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1039 break;
1040
2b0337b0 1041 case EM_D30V:
252b5132 1042 case EM_CYGNUS_D30V:
9ea033b2 1043 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1044 break;
1045
d172d4ba
NC		 1046 case EM_DLX:
1047 rtype = elf_dlx_reloc_type (type);
1048 break;
1049
252b5132 1050 case EM_SH:
9ea033b2 1051 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1052 break;
1053
2b0337b0 1054 case EM_MN10300:
252b5132 1055 case EM_CYGNUS_MN10300:
9ea033b2 1056 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1057 break;
1058
2b0337b0 1059 case EM_MN10200:
252b5132 1060 case EM_CYGNUS_MN10200:
9ea033b2 1061 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1062 break;
1063
2b0337b0 1064 case EM_FR30:
252b5132 1065 case EM_CYGNUS_FR30:
9ea033b2 1066 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1067 break;
1068
ba2685cc
AM		 1069 case EM_CYGNUS_FRV:
1070 rtype = elf_frv_reloc_type (type);
1071 break;
5c70f934 1072
252b5132 1073 case EM_MCORE:
9ea033b2 1074 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1075 break;
1076
3c3bdf30
NC		 1077 case EM_MMIX:
1078 rtype = elf_mmix_reloc_type (type);
1079 break;
1080
5506d11a
AM		 1081 case EM_MOXIE:
1082 rtype = elf_moxie_reloc_type (type);
1083 break;
1084
2469cfa2
NC		 1085 case EM_MSP430:
1086 case EM_MSP430_OLD:
1087 rtype = elf_msp430_reloc_type (type);
1088 break;
1089
252b5132 1090 case EM_PPC:
9ea033b2 1091 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1092 break;
1093
c833c019
AM		 1094 case EM_PPC64:
1095 rtype = elf_ppc64_reloc_type (type);
1096 break;
1097
252b5132 1098 case EM_MIPS:
4fe85591 1099 case EM_MIPS_RS3_LE:
9ea033b2 1100 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1101 break;
1102
1103 case EM_ALPHA:
9ea033b2 1104 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1105 break;
1106
1107 case EM_ARM:
9ea033b2 1108 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1109 break;
1110
584da044 1111 case EM_ARC:
9ea033b2 1112 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1113 break;
1114
1115 case EM_PARISC:
69e617ca 1116 rtype = elf_hppa_reloc_type (type);
252b5132 1117 break;
7d466069 1118
b8720f9d
JL		 1119 case EM_H8_300:
1120 case EM_H8_300H:
1121 case EM_H8S:
1122 rtype = elf_h8_reloc_type (type);
1123 break;
1124
3b16e843
NC		 1125 case EM_OPENRISC:
1126 case EM_OR32:
1127 rtype = elf_or32_reloc_type (type);
1128 break;
1129
7d466069 1130 case EM_PJ:
2b0337b0 1131 case EM_PJ_OLD:
7d466069
ILT		 1132 rtype = elf_pj_reloc_type (type);
1133 break;
800eeca4
JW		 1134 case EM_IA_64:
1135 rtype = elf_ia64_reloc_type (type);
1136 break;
1b61cf92
HPN		 1137
1138 case EM_CRIS:
1139 rtype = elf_cris_reloc_type (type);
1140 break;
535c37ff
JE		 1141
1142 case EM_860:
1143 rtype = elf_i860_reloc_type (type);
1144 break;
bcedfee6
NC		 1145
1146 case EM_X86_64:
8a9036a4 1147 case EM_L1OM:
7a9068fe 1148 case EM_K1OM:
bcedfee6
NC		 1149 rtype = elf_x86_64_reloc_type (type);
1150 break;
a85d7ed0 1151
35b1837e
AM		 1152 case EM_S370:
1153 rtype = i370_reloc_type (type);
1154 break;
1155
53c7db4b
KH		 1156 case EM_S390_OLD:
1157 case EM_S390:
1158 rtype = elf_s390_reloc_type (type);
1159 break;
93fbbb04 1160
1c0d3aa6
NC		 1161 case EM_SCORE:
1162 rtype = elf_score_reloc_type (type);
1163 break;
1164
93fbbb04
GK		 1165 case EM_XSTORMY16:
1166 rtype = elf_xstormy16_reloc_type (type);
1167 break;
179d3252 1168
1fe1f39c
NC		 1169 case EM_CRX:
1170 rtype = elf_crx_reloc_type (type);
1171 break;
1172
179d3252
JT		 1173 case EM_VAX:
1174 rtype = elf_vax_reloc_type (type);
1175 break;
1e4cf259 1176
cfb8c092
NC		 1177 case EM_ADAPTEVA_EPIPHANY:
1178 rtype = elf_epiphany_reloc_type (type);
1179 break;
1180
1e4cf259
NC		 1181 case EM_IP2K:
1182 case EM_IP2K_OLD:
1183 rtype = elf_ip2k_reloc_type (type);
1184 break;
3b36097d
SC		 1185
1186 case EM_IQ2000:
1187 rtype = elf_iq2000_reloc_type (type);
1188 break;
88da6820
NC		 1189
1190 case EM_XTENSA_OLD:
1191 case EM_XTENSA:
1192 rtype = elf_xtensa_reloc_type (type);
1193 break;
a34e3ecb 1194
84e94c90
NC		 1195 case EM_LATTICEMICO32:
1196 rtype = elf_lm32_reloc_type (type);
1197 break;
1198
ff7eeb89 1199 case EM_M32C_OLD:
49f58d10
JB		 1200 case EM_M32C:
1201 rtype = elf_m32c_reloc_type (type);
1202 break;
1203
d031aafb
NS		 1204 case EM_MT:
1205 rtype = elf_mt_reloc_type (type);
a34e3ecb 1206 break;
1d65ded4
CM		 1207
1208 case EM_BLACKFIN:
1209 rtype = elf_bfin_reloc_type (type);
1210 break;
15ab5209
DB		 1211
1212 case EM_CYGNUS_MEP:
1213 rtype = elf_mep_reloc_type (type);
1214 break;
60bca95a
NC		 1215
1216 case EM_CR16:
1217 rtype = elf_cr16_reloc_type (type);
1218 break;
dd24e3da 1219
7ba29e2a
NC		 1220 case EM_MICROBLAZE:
1221 case EM_MICROBLAZE_OLD:
1222 rtype = elf_microblaze_reloc_type (type);
1223 break;
c7927a3c 1224
99c513f6
DD		 1225 case EM_RL78:
1226 rtype = elf_rl78_reloc_type (type);
1227 break;
1228
c7927a3c
NC		 1229 case EM_RX:
1230 rtype = elf_rx_reloc_type (type);
1231 break;
c29aca4a
NC		 1232
1233 case EM_XC16X:
1234 case EM_C166:
1235 rtype = elf_xc16x_reloc_type (type);
1236 break;
40b36596
JM		 1237
1238 case EM_TI_C6000:
1239 rtype = elf_tic6x_reloc_type (type);
1240 break;
aa137e4d
NC		 1241
1242 case EM_TILEGX:
1243 rtype = elf_tilegx_reloc_type (type);
1244 break;
1245
1246 case EM_TILEPRO:
1247 rtype = elf_tilepro_reloc_type (type);
1248 break;
f6c1a2d5
NC		 1249
1250 case EM_XGATE:
1251 rtype = elf_xgate_reloc_type (type);
1252 break;
252b5132
RH		 1253 }
1254
1255 if (rtype == NULL)
39dbeff8 1256 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1257 else
8beeaeb7 1258 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1259
7ace3541 1260 if (elf_header.e_machine == EM_ALPHA
157c2599 1261 && rtype != NULL
7ace3541
RH		 1262 && streq (rtype, "R_ALPHA_LITUSE")
1263 && is_rela)
1264 {
1265 switch (rels[i].r_addend)
1266 {
1267 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1268 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1269 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1270 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1271 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1272 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1273 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1274 default: rtype = NULL;
1275 }
1276 if (rtype)
1277 printf (" (%s)", rtype);
1278 else
1279 {
1280 putchar (' ');
1281 printf (_("<unknown addend: %lx>"),
1282 (unsigned long) rels[i].r_addend);
1283 }
1284 }
1285 else if (symtab_index)
252b5132 1286 {
af3fc3bc 1287 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1288 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1289 else
19936277 1290 {
2cf0635d 1291 Elf_Internal_Sym * psym;
19936277 1292
af3fc3bc 1293 psym = symtab + symtab_index;
103f02d3 1294
af3fc3bc 1295 printf (" ");
171191ba 1296
d8045f23
NC		 1297 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1298 {
1299 const char * name;
1300 unsigned int len;
1301 unsigned int width = is_32bit_elf ? 8 : 14;
1302
1303 /* Relocations against GNU_IFUNC symbols do not use the value
1304 of the symbol as the address to relocate against. Instead
1305 they invoke the function named by the symbol and use its
1306 result as the address for relocation.
1307
1308 To indicate this to the user, do not display the value of
1309 the symbol in the "Symbols's Value" field. Instead show
1310 its name followed by () as a hint that the symbol is
1311 invoked. */
1312
1313 if (strtab == NULL
1314 || psym->st_name == 0
1315 || psym->st_name >= strtablen)
1316 name = "??";
1317 else
1318 name = strtab + psym->st_name;
1319
1320 len = print_symbol (width, name);
1321 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1322 }
1323 else
1324 {
1325 print_vma (psym->st_value, LONG_HEX);
171191ba 1326
d8045f23
NC		 1327 printf (is_32bit_elf ? " " : " ");
1328 }
103f02d3 1329
af3fc3bc 1330 if (psym->st_name == 0)
f1ef08cb 1331 {
2cf0635d 1332 const char * sec_name = "<null>";
f1ef08cb
AM		 1333 char name_buf[40];
1334
1335 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1336 {
4fbb74a6
AM		 1337 if (psym->st_shndx < elf_header.e_shnum)
1338 sec_name
1339 = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1340 else if (psym->st_shndx == SHN_ABS)
1341 sec_name = "ABS";
1342 else if (psym->st_shndx == SHN_COMMON)
1343 sec_name = "COMMON";
ac145307
BS		 1344 else if ((elf_header.e_machine == EM_MIPS
1345 && psym->st_shndx == SHN_MIPS_SCOMMON)
1346 || (elf_header.e_machine == EM_TI_C6000
1347 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1348 sec_name = "SCOMMON";
1349 else if (elf_header.e_machine == EM_MIPS
1350 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1351 sec_name = "SUNDEF";
8a9036a4 1352 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1353 || elf_header.e_machine == EM_L1OM
1354 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1355 && psym->st_shndx == SHN_X86_64_LCOMMON)
1356 sec_name = "LARGE_COMMON";
9ce701e2
L		 1357 else if (elf_header.e_machine == EM_IA_64
1358 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1359 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1360 sec_name = "ANSI_COM";
28f997cf 1361 else if (is_ia64_vms ()
148b93f2
NC		 1362 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1363 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1364 else
1365 {
1366 sprintf (name_buf, "<section 0x%x>",
1367 (unsigned int) psym->st_shndx);
1368 sec_name = name_buf;
1369 }
1370 }
1371 print_symbol (22, sec_name);
1372 }
af3fc3bc 1373 else if (strtab == NULL)
d79b3d50 1374 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1375 else if (psym->st_name >= strtablen)
d79b3d50 1376 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1377 else
2c71103e 1378 print_symbol (22, strtab + psym->st_name);
103f02d3 1379
af3fc3bc 1380 if (is_rela)
171191ba 1381 {
598aaa76 1382 bfd_signed_vma off = rels[i].r_addend;
171191ba 1383
91d6fa6a 1384 if (off < 0)
598aaa76 1385 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1386 else
598aaa76 1387 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1388 }
19936277 1389 }
252b5132 1390 }
1b228002 1391 else if (is_rela)
f7a99963 1392 {
e04d7088
L		 1393 bfd_signed_vma off = rels[i].r_addend;
1394
1395 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1396 if (off < 0)
1397 printf ("-%" BFD_VMA_FMT "x", - off);
1398 else
1399 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1400 }
252b5132 1401
157c2599
NC		 1402 if (elf_header.e_machine == EM_SPARCV9
1403 && rtype != NULL
1404 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1405 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1406
252b5132 1407 putchar ('\n');
2c71103e 1408
aca88567 1409#ifdef BFD64
53c7db4b 1410 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1411 {
91d6fa6a
NC		 1412 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1413 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1414 const char * rtype2 = elf_mips_reloc_type (type2);
1415 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1416
2c71103e
NC		 1417 printf (" Type2: ");
1418
1419 if (rtype2 == NULL)
39dbeff8
AM		 1420 printf (_("unrecognized: %-7lx"),
1421 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1422 else
1423 printf ("%-17.17s", rtype2);
1424
18bd398b 1425 printf ("\n Type3: ");
2c71103e
NC		 1426
1427 if (rtype3 == NULL)
39dbeff8
AM		 1428 printf (_("unrecognized: %-7lx"),
1429 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1430 else
1431 printf ("%-17.17s", rtype3);
1432
53c7db4b 1433 putchar ('\n');
2c71103e 1434 }
aca88567 1435#endif /* BFD64 */
252b5132
RH		 1436 }
1437
c8286bd1 1438 free (rels);
252b5132
RH		 1439}
1440
1441static const char *
d3ba0551 1442get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1443{
1444 switch (type)
1445 {
1446 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1447 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1448 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1449 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1450 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1451 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1452 case DT_MIPS_MSYM: return "MIPS_MSYM";
1453 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1454 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1455 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1456 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1457 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1458 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1459 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1460 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1461 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1462 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1463 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1464 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1465 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1466 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1467 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1468 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1469 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1470 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1471 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1472 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1473 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1474 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1475 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1476 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1477 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1478 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1479 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1480 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1481 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1482 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1483 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1484 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1485 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1486 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1487 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1488 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1489 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1490 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1491 default:
1492 return NULL;
1493 }
1494}
1495
9a097730 1496static const char *
d3ba0551 1497get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1498{
1499 switch (type)
1500 {
1501 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1502 default:
1503 return NULL;
1504 }
103f02d3
UD		 1505}
1506
7490d522
AM		 1507static const char *
1508get_ppc_dynamic_type (unsigned long type)
1509{
1510 switch (type)
1511 {
a7f2871e
AM		 1512 case DT_PPC_GOT: return "PPC_GOT";
1513 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
7490d522
AM		 1514 default:
1515 return NULL;
1516 }
1517}
1518
f1cb7e17 1519static const char *
d3ba0551 1520get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1521{
1522 switch (type)
1523 {
a7f2871e
AM		 1524 case DT_PPC64_GLINK: return "PPC64_GLINK";
1525 case DT_PPC64_OPD: return "PPC64_OPD";
1526 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1527 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
f1cb7e17
AM		 1528 default:
1529 return NULL;
1530 }
1531}
1532
103f02d3 1533static const char *
d3ba0551 1534get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1535{
1536 switch (type)
1537 {
1538 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1539 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1540 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1541 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1542 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1543 case DT_HP_PREINIT: return "HP_PREINIT";
1544 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1545 case DT_HP_NEEDED: return "HP_NEEDED";
1546 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1547 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1548 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1549 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1550 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1551 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1552 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1553 case DT_HP_FILTERED: return "HP_FILTERED";
1554 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1555 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1556 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1557 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1558 case DT_PLT: return "PLT";
1559 case DT_PLT_SIZE: return "PLT_SIZE";
1560 case DT_DLT: return "DLT";
1561 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1562 default:
1563 return NULL;
1564 }
1565}
9a097730 1566
ecc51f48 1567static const char *
d3ba0551 1568get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1569{
1570 switch (type)
1571 {
148b93f2
NC		 1572 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1573 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1574 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1575 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1576 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1577 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1578 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1579 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1580 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1581 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1582 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1583 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1584 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1585 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1586 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1587 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1588 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1589 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1590 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1591 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1592 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1593 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1594 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1595 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1596 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1597 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1598 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1599 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1600 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1601 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1602 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1603 default:
1604 return NULL;
1605 }
1606}
1607
fabcb361
RH		 1608static const char *
1609get_alpha_dynamic_type (unsigned long type)
1610{
1611 switch (type)
1612 {
1613 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1614 default:
1615 return NULL;
1616 }
1617}
1618
1c0d3aa6
NC		 1619static const char *
1620get_score_dynamic_type (unsigned long type)
1621{
1622 switch (type)
1623 {
1624 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1625 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1626 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1627 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1628 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1629 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1630 default:
1631 return NULL;
1632 }
1633}
1634
40b36596
JM		 1635static const char *
1636get_tic6x_dynamic_type (unsigned long type)
1637{
1638 switch (type)
1639 {
1640 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1641 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1642 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1643 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1644 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1645 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1646 default:
1647 return NULL;
1648 }
1649}
1c0d3aa6 1650
252b5132 1651static const char *
d3ba0551 1652get_dynamic_type (unsigned long type)
252b5132 1653{
e9e44622 1654 static char buff[64];
252b5132
RH		 1655
1656 switch (type)
1657 {
1658 case DT_NULL: return "NULL";
1659 case DT_NEEDED: return "NEEDED";
1660 case DT_PLTRELSZ: return "PLTRELSZ";
1661 case DT_PLTGOT: return "PLTGOT";
1662 case DT_HASH: return "HASH";
1663 case DT_STRTAB: return "STRTAB";
1664 case DT_SYMTAB: return "SYMTAB";
1665 case DT_RELA: return "RELA";
1666 case DT_RELASZ: return "RELASZ";
1667 case DT_RELAENT: return "RELAENT";
1668 case DT_STRSZ: return "STRSZ";
1669 case DT_SYMENT: return "SYMENT";
1670 case DT_INIT: return "INIT";
1671 case DT_FINI: return "FINI";
1672 case DT_SONAME: return "SONAME";
1673 case DT_RPATH: return "RPATH";
1674 case DT_SYMBOLIC: return "SYMBOLIC";
1675 case DT_REL: return "REL";
1676 case DT_RELSZ: return "RELSZ";
1677 case DT_RELENT: return "RELENT";
1678 case DT_PLTREL: return "PLTREL";
1679 case DT_DEBUG: return "DEBUG";
1680 case DT_TEXTREL: return "TEXTREL";
1681 case DT_JMPREL: return "JMPREL";
1682 case DT_BIND_NOW: return "BIND_NOW";
1683 case DT_INIT_ARRAY: return "INIT_ARRAY";
1684 case DT_FINI_ARRAY: return "FINI_ARRAY";
1685 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1686 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1687 case DT_RUNPATH: return "RUNPATH";
1688 case DT_FLAGS: return "FLAGS";
2d0e6f43 1689
d1133906
NC		 1690 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1691 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1692
05107a46 1693 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1694 case DT_PLTPADSZ: return "PLTPADSZ";
1695 case DT_MOVEENT: return "MOVEENT";
1696 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1697 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1698 case DT_POSFLAG_1: return "POSFLAG_1";
1699 case DT_SYMINSZ: return "SYMINSZ";
1700 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1701
252b5132 1702 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1703 case DT_CONFIG: return "CONFIG";
1704 case DT_DEPAUDIT: return "DEPAUDIT";
1705 case DT_AUDIT: return "AUDIT";
1706 case DT_PLTPAD: return "PLTPAD";
1707 case DT_MOVETAB: return "MOVETAB";
252b5132 1708 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1709
252b5132 1710 case DT_VERSYM: return "VERSYM";
103f02d3 1711
67a4f2b7
AO		 1712 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1713 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1714 case DT_RELACOUNT: return "RELACOUNT";
1715 case DT_RELCOUNT: return "RELCOUNT";
1716 case DT_FLAGS_1: return "FLAGS_1";
1717 case DT_VERDEF: return "VERDEF";
1718 case DT_VERDEFNUM: return "VERDEFNUM";
1719 case DT_VERNEED: return "VERNEED";
1720 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1721
019148e4 1722 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1723 case DT_USED: return "USED";
1724 case DT_FILTER: return "FILTER";
103f02d3 1725
047b2264
JJ		 1726 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1727 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1728 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1729 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1730 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1731 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1732
252b5132
RH		 1733 default:
1734 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1735 {
2cf0635d 1736 const char * result;
103f02d3 1737
252b5132
RH		 1738 switch (elf_header.e_machine)
1739 {
1740 case EM_MIPS:
4fe85591 1741 case EM_MIPS_RS3_LE:
252b5132
RH		 1742 result = get_mips_dynamic_type (type);
1743 break;
9a097730
RH		 1744 case EM_SPARCV9:
1745 result = get_sparc64_dynamic_type (type);
1746 break;
7490d522
AM		 1747 case EM_PPC:
1748 result = get_ppc_dynamic_type (type);
1749 break;
f1cb7e17
AM		 1750 case EM_PPC64:
1751 result = get_ppc64_dynamic_type (type);
1752 break;
ecc51f48
NC		 1753 case EM_IA_64:
1754 result = get_ia64_dynamic_type (type);
1755 break;
fabcb361
RH		 1756 case EM_ALPHA:
1757 result = get_alpha_dynamic_type (type);
1758 break;
1c0d3aa6
NC		 1759 case EM_SCORE:
1760 result = get_score_dynamic_type (type);
1761 break;
40b36596
JM		 1762 case EM_TI_C6000:
1763 result = get_tic6x_dynamic_type (type);
1764 break;
252b5132
RH		 1765 default:
1766 result = NULL;
1767 break;
1768 }
1769
1770 if (result != NULL)
1771 return result;
1772
e9e44622 1773 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 1774 }
eec8f817
DA		 1775 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1776 || (elf_header.e_machine == EM_PARISC
1777 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 1778 {
2cf0635d 1779 const char * result;
103f02d3
UD		 1780
1781 switch (elf_header.e_machine)
1782 {
1783 case EM_PARISC:
1784 result = get_parisc_dynamic_type (type);
1785 break;
148b93f2
NC		 1786 case EM_IA_64:
1787 result = get_ia64_dynamic_type (type);
1788 break;
103f02d3
UD		 1789 default:
1790 result = NULL;
1791 break;
1792 }
1793
1794 if (result != NULL)
1795 return result;
1796
e9e44622
JJ		 1797 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1798 type);
103f02d3 1799 }
252b5132 1800 else
e9e44622 1801 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 1802
252b5132
RH		 1803 return buff;
1804 }
1805}
1806
1807static char *
d3ba0551 1808get_file_type (unsigned e_type)
252b5132 1809{
b34976b6 1810 static char buff[32];
252b5132
RH		 1811
1812 switch (e_type)
1813 {
1814 case ET_NONE: return _("NONE (None)");
1815 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 1816 case ET_EXEC: return _("EXEC (Executable file)");
1817 case ET_DYN: return _("DYN (Shared object file)");
1818 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 1819
1820 default:
1821 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 1822 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 1823 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 1824 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 1825 else
e9e44622 1826 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 1827 return buff;
1828 }
1829}
1830
1831static char *
d3ba0551 1832get_machine_name (unsigned e_machine)
252b5132 1833{
b34976b6 1834 static char buff[64]; /* XXX */
252b5132
RH		 1835
1836 switch (e_machine)
1837 {
c45021f2 1838 case EM_NONE: return _("None");
a06ea964 1839 case EM_AARCH64: return "AArch64";
c45021f2
NC		 1840 case EM_M32: return "WE32100";
1841 case EM_SPARC: return "Sparc";
e9f53129 1842 case EM_SPU: return "SPU";
c45021f2
NC		 1843 case EM_386: return "Intel 80386";
1844 case EM_68K: return "MC68000";
1845 case EM_88K: return "MC88000";
1846 case EM_486: return "Intel 80486";
1847 case EM_860: return "Intel 80860";
1848 case EM_MIPS: return "MIPS R3000";
1849 case EM_S370: return "IBM System/370";
7036c0e1 1850 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 1851 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 1852 case EM_PARISC: return "HPPA";
252b5132 1853 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 1854 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 1855 case EM_960: return "Intel 90860";
1856 case EM_PPC: return "PowerPC";
285d1771 1857 case EM_PPC64: return "PowerPC64";
c45021f2
NC		 1858 case EM_V800: return "NEC V800";
1859 case EM_FR20: return "Fujitsu FR20";
1860 case EM_RH32: return "TRW RH32";
b34976b6 1861 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 1862 case EM_ARM: return "ARM";
1863 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 1864 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 1865 case EM_SPARCV9: return "Sparc v9";
1866 case EM_TRICORE: return "Siemens Tricore";
584da044 1867 case EM_ARC: return "ARC";
c2dcd04e
NC		 1868 case EM_H8_300: return "Renesas H8/300";
1869 case EM_H8_300H: return "Renesas H8/300H";
1870 case EM_H8S: return "Renesas H8S";
1871 case EM_H8_500: return "Renesas H8/500";
30800947 1872 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1873 case EM_MIPS_X: return "Stanford MIPS-X";
1874 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 1875 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 1876 case EM_CYGNUS_D10V:
1877 case EM_D10V: return "d10v";
1878 case EM_CYGNUS_D30V:
b34976b6 1879 case EM_D30V: return "d30v";
2b0337b0 1880 case EM_CYGNUS_M32R:
26597c86 1881 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 1882 case EM_CYGNUS_V850:
f6c1a2d5 1883 case EM_V850: return "Renesas V850";
2b0337b0
AO		 1884 case EM_CYGNUS_MN10300:
1885 case EM_MN10300: return "mn10300";
1886 case EM_CYGNUS_MN10200:
1887 case EM_MN10200: return "mn10200";
5506d11a 1888 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 1889 case EM_CYGNUS_FR30:
1890 case EM_FR30: return "Fujitsu FR30";
b34976b6 1891 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 1892 case EM_PJ_OLD:
b34976b6 1893 case EM_PJ: return "picoJava";
7036c0e1
AJ		 1894 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1895 case EM_PCP: return "Siemens PCP";
1896 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1897 case EM_NDR1: return "Denso NDR1 microprocesspr";
1898 case EM_STARCORE: return "Motorola Star*Core processor";
1899 case EM_ME16: return "Toyota ME16 processor";
1900 case EM_ST100: return "STMicroelectronics ST100 processor";
1901 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 1902 case EM_PDSP: return "Sony DSP processor";
1903 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1904 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 1905 case EM_FX66: return "Siemens FX66 microcontroller";
1906 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1907 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1908 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 1909 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 1910 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1911 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1912 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1913 case EM_SVX: return "Silicon Graphics SVx";
1914 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1915 case EM_VAX: return "Digital VAX";
2b0337b0 1916 case EM_AVR_OLD:
b34976b6 1917 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 1918 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 1919 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1920 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1921 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 1922 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 1923 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 1924 case EM_PRISM: return "Vitesse Prism";
bcedfee6 1925 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 1926 case EM_L1OM: return "Intel L1OM";
7a9068fe 1927 case EM_K1OM: return "Intel K1OM";
b7498e0e 1928 case EM_S390_OLD:
b34976b6 1929 case EM_S390: return "IBM S/390";
1c0d3aa6 1930 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 1931 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
3b16e843
NC		 1932 case EM_OPENRISC:
1933 case EM_OR32: return "OpenRISC";
11636f9e 1934 case EM_ARC_A5: return "ARC International ARCompact processor";
1fe1f39c 1935 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 1936 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 1937 case EM_DLX: return "OpenDLX";
1e4cf259 1938 case EM_IP2K_OLD:
b34976b6 1939 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 1940 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 1941 case EM_XTENSA_OLD:
1942 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 1943 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1944 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1945 case EM_NS32K: return "National Semiconductor 32000 series";
1946 case EM_TPC: return "Tenor Network TPC processor";
1947 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1948 case EM_MAX: return "MAX Processor";
1949 case EM_CR: return "National Semiconductor CompactRISC";
1950 case EM_F2MC16: return "Fujitsu F2MC16";
1951 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 1952 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 1953 case EM_M32C_OLD:
49f58d10 1954 case EM_M32C: return "Renesas M32c";
d031aafb 1955 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 1956 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 1957 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1958 case EM_SEP: return "Sharp embedded microprocessor";
1959 case EM_ARCA: return "Arca RISC microprocessor";
1960 case EM_UNICORE: return "Unicore";
1961 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1962 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 1963 case EM_NIOS32: return "Altera Nios";
1964 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 1965 case EM_C166:
d70c5fc7 1966 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 1967 case EM_M16C: return "Renesas M16C series microprocessors";
1968 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1969 case EM_CE: return "Freescale Communication Engine RISC core";
1970 case EM_TSK3000: return "Altium TSK3000 core";
1971 case EM_RS08: return "Freescale RS08 embedded processor";
1972 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1973 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1974 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1975 case EM_SE_C17: return "Seiko Epson C17 family";
1976 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1977 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1978 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1979 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1980 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1981 case EM_R32C: return "Renesas R32C series microprocessors";
1982 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1983 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1984 case EM_8051: return "Intel 8051 and variants";
1985 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1986 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1987 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1988 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1989 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1990 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1991 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 1992 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 1993 case EM_CR16:
f6c1a2d5 1994 case EM_MICROBLAZE:
7ba29e2a 1995 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 1996 case EM_RL78: return "Renesas RL78";
c7927a3c 1997 case EM_RX: return "Renesas RX";
11636f9e
JM		 1998 case EM_METAG: return "Imagination Technologies META processor architecture";
1999 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2000 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2001 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2002 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2003 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2004 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2005 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2006 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2007 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2008 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2009 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2010 default:
35d9dd2f 2011 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2012 return buff;
2013 }
2014}
2015
f3485b74 2016static void
d3ba0551 2017decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2018{
2019 unsigned eabi;
2020 int unknown = 0;
2021
2022 eabi = EF_ARM_EABI_VERSION (e_flags);
2023 e_flags &= ~ EF_ARM_EABIMASK;
2024
2025 /* Handle "generic" ARM flags. */
2026 if (e_flags & EF_ARM_RELEXEC)
2027 {
2028 strcat (buf, ", relocatable executable");
2029 e_flags &= ~ EF_ARM_RELEXEC;
2030 }
76da6bbe 2031
f3485b74
NC		 2032 if (e_flags & EF_ARM_HASENTRY)
2033 {
2034 strcat (buf, ", has entry point");
2035 e_flags &= ~ EF_ARM_HASENTRY;
2036 }
76da6bbe 2037
f3485b74
NC		 2038 /* Now handle EABI specific flags. */
2039 switch (eabi)
2040 {
2041 default:
2c71103e 2042 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2043 if (e_flags)
2044 unknown = 1;
2045 break;
2046
2047 case EF_ARM_EABI_VER1:
a5bcd848 2048 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2049 while (e_flags)
2050 {
2051 unsigned flag;
76da6bbe 2052
f3485b74
NC		 2053 /* Process flags one bit at a time. */
2054 flag = e_flags & - e_flags;
2055 e_flags &= ~ flag;
76da6bbe 2056
f3485b74
NC		 2057 switch (flag)
2058 {
a5bcd848 2059 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2060 strcat (buf, ", sorted symbol tables");
2061 break;
76da6bbe 2062
f3485b74
NC		 2063 default:
2064 unknown = 1;
2065 break;
2066 }
2067 }
2068 break;
76da6bbe 2069
a5bcd848
PB		 2070 case EF_ARM_EABI_VER2:
2071 strcat (buf, ", Version2 EABI");
2072 while (e_flags)
2073 {
2074 unsigned flag;
2075
2076 /* Process flags one bit at a time. */
2077 flag = e_flags & - e_flags;
2078 e_flags &= ~ flag;
2079
2080 switch (flag)
2081 {
2082 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2083 strcat (buf, ", sorted symbol tables");
2084 break;
2085
2086 case EF_ARM_DYNSYMSUSESEGIDX:
2087 strcat (buf, ", dynamic symbols use segment index");
2088 break;
2089
2090 case EF_ARM_MAPSYMSFIRST:
2091 strcat (buf, ", mapping symbols precede others");
2092 break;
2093
2094 default:
2095 unknown = 1;
2096 break;
2097 }
2098 }
2099 break;
2100
d507cf36
PB		 2101 case EF_ARM_EABI_VER3:
2102 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2103 break;
2104
2105 case EF_ARM_EABI_VER4:
2106 strcat (buf, ", Version4 EABI");
3a4a14e9
PB		 2107 goto eabi;
2108
2109 case EF_ARM_EABI_VER5:
2110 strcat (buf, ", Version5 EABI");
2111 eabi:
d507cf36
PB		 2112 while (e_flags)
2113 {
2114 unsigned flag;
2115
2116 /* Process flags one bit at a time. */
2117 flag = e_flags & - e_flags;
2118 e_flags &= ~ flag;
2119
2120 switch (flag)
2121 {
2122 case EF_ARM_BE8:
2123 strcat (buf, ", BE8");
2124 break;
2125
2126 case EF_ARM_LE8:
2127 strcat (buf, ", LE8");
2128 break;
2129
2130 default:
2131 unknown = 1;
2132 break;
2133 }
2134 }
2135 break;
2136
f3485b74 2137 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2138 strcat (buf, ", GNU EABI");
f3485b74
NC		 2139 while (e_flags)
2140 {
2141 unsigned flag;
76da6bbe 2142
f3485b74
NC		 2143 /* Process flags one bit at a time. */
2144 flag = e_flags & - e_flags;
2145 e_flags &= ~ flag;
76da6bbe 2146
f3485b74
NC		 2147 switch (flag)
2148 {
a5bcd848 2149 case EF_ARM_INTERWORK:
f3485b74
NC		 2150 strcat (buf, ", interworking enabled");
2151 break;
76da6bbe 2152
a5bcd848 2153 case EF_ARM_APCS_26:
f3485b74
NC		 2154 strcat (buf, ", uses APCS/26");
2155 break;
76da6bbe 2156
a5bcd848 2157 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2158 strcat (buf, ", uses APCS/float");
2159 break;
76da6bbe 2160
a5bcd848 2161 case EF_ARM_PIC:
f3485b74
NC		 2162 strcat (buf, ", position independent");
2163 break;
76da6bbe 2164
a5bcd848 2165 case EF_ARM_ALIGN8:
f3485b74
NC		 2166 strcat (buf, ", 8 bit structure alignment");
2167 break;
76da6bbe 2168
a5bcd848 2169 case EF_ARM_NEW_ABI:
f3485b74
NC		 2170 strcat (buf, ", uses new ABI");
2171 break;
76da6bbe 2172
a5bcd848 2173 case EF_ARM_OLD_ABI:
f3485b74
NC		 2174 strcat (buf, ", uses old ABI");
2175 break;
76da6bbe 2176
a5bcd848 2177 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2178 strcat (buf, ", software FP");
2179 break;
76da6bbe 2180
90e01f86
ILT		 2181 case EF_ARM_VFP_FLOAT:
2182 strcat (buf, ", VFP");
2183 break;
2184
fde78edd
NC		 2185 case EF_ARM_MAVERICK_FLOAT:
2186 strcat (buf, ", Maverick FP");
2187 break;
2188
f3485b74
NC		 2189 default:
2190 unknown = 1;
2191 break;
2192 }
2193 }
2194 }
f3485b74
NC		 2195
2196 if (unknown)
2b692964 2197 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2198}
2199
252b5132 2200static char *
d3ba0551 2201get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2202{
b34976b6 2203 static char buf[1024];
252b5132
RH		 2204
2205 buf[0] = '\0';
76da6bbe 2206
252b5132
RH		 2207 if (e_flags)
2208 {
2209 switch (e_machine)
2210 {
2211 default:
2212 break;
2213
f3485b74
NC		 2214 case EM_ARM:
2215 decode_ARM_machine_flags (e_flags, buf);
2216 break;
76da6bbe 2217
781303ce
MF		 2218 case EM_BLACKFIN:
2219 if (e_flags & EF_BFIN_PIC)
2220 strcat (buf, ", PIC");
2221
2222 if (e_flags & EF_BFIN_FDPIC)
2223 strcat (buf, ", FDPIC");
2224
2225 if (e_flags & EF_BFIN_CODE_IN_L1)
2226 strcat (buf, ", code in L1");
2227
2228 if (e_flags & EF_BFIN_DATA_IN_L1)
2229 strcat (buf, ", data in L1");
2230
2231 break;
2232
ec2dfb42
AO		 2233 case EM_CYGNUS_FRV:
2234 switch (e_flags & EF_FRV_CPU_MASK)
2235 {
2236 case EF_FRV_CPU_GENERIC:
2237 break;
2238
2239 default:
2240 strcat (buf, ", fr???");
2241 break;
57346661 2242
ec2dfb42
AO		 2243 case EF_FRV_CPU_FR300:
2244 strcat (buf, ", fr300");
2245 break;
2246
2247 case EF_FRV_CPU_FR400:
2248 strcat (buf, ", fr400");
2249 break;
2250 case EF_FRV_CPU_FR405:
2251 strcat (buf, ", fr405");
2252 break;
2253
2254 case EF_FRV_CPU_FR450:
2255 strcat (buf, ", fr450");
2256 break;
2257
2258 case EF_FRV_CPU_FR500:
2259 strcat (buf, ", fr500");
2260 break;
2261 case EF_FRV_CPU_FR550:
2262 strcat (buf, ", fr550");
2263 break;
2264
2265 case EF_FRV_CPU_SIMPLE:
2266 strcat (buf, ", simple");
2267 break;
2268 case EF_FRV_CPU_TOMCAT:
2269 strcat (buf, ", tomcat");
2270 break;
2271 }
1c877e87 2272 break;
ec2dfb42 2273
53c7db4b 2274 case EM_68K:
425c6cb0 2275 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2276 strcat (buf, ", m68000");
425c6cb0 2277 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2278 strcat (buf, ", cpu32");
2279 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2280 strcat (buf, ", fido_a");
425c6cb0 2281 else
266abb8f 2282 {
2cf0635d
NC		 2283 char const * isa = _("unknown");
2284 char const * mac = _("unknown mac");
2285 char const * additional = NULL;
0112cd26 2286
c694fd50 2287 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2288 {
c694fd50 2289 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2290 isa = "A";
2291 additional = ", nodiv";
2292 break;
c694fd50 2293 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2294 isa = "A";
2295 break;
c694fd50 2296 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2297 isa = "A+";
2298 break;
c694fd50 2299 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2300 isa = "B";
2301 additional = ", nousp";
2302 break;
c694fd50 2303 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2304 isa = "B";
2305 break;
f608cd77
NS		 2306 case EF_M68K_CF_ISA_C:
2307 isa = "C";
2308 break;
2309 case EF_M68K_CF_ISA_C_NODIV:
2310 isa = "C";
2311 additional = ", nodiv";
2312 break;
266abb8f
NS		 2313 }
2314 strcat (buf, ", cf, isa ");
2315 strcat (buf, isa);
0b2e31dc
NS		 2316 if (additional)
2317 strcat (buf, additional);
c694fd50 2318 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2319 strcat (buf, ", float");
c694fd50 2320 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2321 {
2322 case 0:
2323 mac = NULL;
2324 break;
c694fd50 2325 case EF_M68K_CF_MAC:
266abb8f
NS		 2326 mac = "mac";
2327 break;
c694fd50 2328 case EF_M68K_CF_EMAC:
266abb8f
NS		 2329 mac = "emac";
2330 break;
f608cd77
NS		 2331 case EF_M68K_CF_EMAC_B:
2332 mac = "emac_b";
2333 break;
266abb8f
NS		 2334 }
2335 if (mac)
2336 {
2337 strcat (buf, ", ");
2338 strcat (buf, mac);
2339 }
266abb8f 2340 }
53c7db4b 2341 break;
33c63f9d 2342
252b5132
RH		 2343 case EM_PPC:
2344 if (e_flags & EF_PPC_EMB)
2345 strcat (buf, ", emb");
2346
2347 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2348 strcat (buf, _(", relocatable"));
252b5132
RH		 2349
2350 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 2351 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 2352 break;
2353
2b0337b0 2354 case EM_V850:
252b5132
RH		 2355 case EM_CYGNUS_V850:
2356 switch (e_flags & EF_V850_ARCH)
2357 {
1cd986c5
NC		 2358 case E_V850E2V3_ARCH:
2359 strcat (buf, ", v850e2v3");
2360 break;
2361 case E_V850E2_ARCH:
2362 strcat (buf, ", v850e2");
2363 break;
2364 case E_V850E1_ARCH:
2365 strcat (buf, ", v850e1");
8ad30312 2366 break;
252b5132
RH		 2367 case E_V850E_ARCH:
2368 strcat (buf, ", v850e");
2369 break;
252b5132
RH		 2370 case E_V850_ARCH:
2371 strcat (buf, ", v850");
2372 break;
2373 default:
2b692964 2374 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 2375 break;
2376 }
2377 break;
2378
2b0337b0 2379 case EM_M32R:
252b5132
RH		 2380 case EM_CYGNUS_M32R:
2381 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2382 strcat (buf, ", m32r");
252b5132
RH		 2383 break;
2384
2385 case EM_MIPS:
4fe85591 2386 case EM_MIPS_RS3_LE:
252b5132
RH		 2387 if (e_flags & EF_MIPS_NOREORDER)
2388 strcat (buf, ", noreorder");
2389
2390 if (e_flags & EF_MIPS_PIC)
2391 strcat (buf, ", pic");
2392
2393 if (e_flags & EF_MIPS_CPIC)
2394 strcat (buf, ", cpic");
2395
d1bdd336
TS		 2396 if (e_flags & EF_MIPS_UCODE)
2397 strcat (buf, ", ugen_reserved");
2398
252b5132
RH		 2399 if (e_flags & EF_MIPS_ABI2)
2400 strcat (buf, ", abi2");
2401
43521d43
TS		 2402 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2403 strcat (buf, ", odk first");
2404
a5d22d2a
TS		 2405 if (e_flags & EF_MIPS_32BITMODE)
2406 strcat (buf, ", 32bitmode");
2407
156c2f8b
NC		 2408 switch ((e_flags & EF_MIPS_MACH))
2409 {
2410 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2411 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2412 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 2413 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 2414 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2415 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2416 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2417 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 2418 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 2419 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 2420 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2421 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 2422 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 2423 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 2424 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
52b6b6b9 2425 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 2426 case 0:
2427 /* We simply ignore the field in this case to avoid confusion:
2428 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2429 extension. */
2430 break;
2b692964 2431 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 2432 }
43521d43
TS		 2433
2434 switch ((e_flags & EF_MIPS_ABI))
2435 {
2436 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2437 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2438 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2439 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2440 case 0:
2441 /* We simply ignore the field in this case to avoid confusion:
2442 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2443 This means it is likely to be an o32 file, but not for
2444 sure. */
2445 break;
2b692964 2446 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 2447 }
2448
2449 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2450 strcat (buf, ", mdmx");
2451
2452 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2453 strcat (buf, ", mips16");
2454
df58fc94
RS		 2455 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2456 strcat (buf, ", micromips");
2457
43521d43
TS		 2458 switch ((e_flags & EF_MIPS_ARCH))
2459 {
2460 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2461 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2462 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2463 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2464 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2465 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 2466 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
43521d43 2467 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 2468 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2b692964 2469 default: strcat (buf, _(", unknown ISA")); break;
43521d43
TS		 2470 }
2471
8e45593f
NC		 2472 if (e_flags & EF_SH_PIC)
2473 strcat (buf, ", pic");
2474
2475 if (e_flags & EF_SH_FDPIC)
2476 strcat (buf, ", fdpic");
252b5132 2477 break;
351b4b40 2478
ccde1100
AO		 2479 case EM_SH:
2480 switch ((e_flags & EF_SH_MACH_MASK))
2481 {
2482 case EF_SH1: strcat (buf, ", sh1"); break;
2483 case EF_SH2: strcat (buf, ", sh2"); break;
2484 case EF_SH3: strcat (buf, ", sh3"); break;
2485 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2486 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2487 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2488 case EF_SH3E: strcat (buf, ", sh3e"); break;
2489 case EF_SH4: strcat (buf, ", sh4"); break;
2490 case EF_SH5: strcat (buf, ", sh5"); break;
2491 case EF_SH2E: strcat (buf, ", sh2e"); break;
2492 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 2493 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 2494 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2495 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 2496 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 2497 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2498 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2499 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2500 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2501 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2502 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 2503 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 2504 }
2505
2506 break;
57346661 2507
351b4b40
RH		 2508 case EM_SPARCV9:
2509 if (e_flags & EF_SPARC_32PLUS)
2510 strcat (buf, ", v8+");
2511
2512 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 2513 strcat (buf, ", ultrasparcI");
2514
2515 if (e_flags & EF_SPARC_SUN_US3)
2516 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 2517
2518 if (e_flags & EF_SPARC_HAL_R1)
2519 strcat (buf, ", halr1");
2520
2521 if (e_flags & EF_SPARC_LEDATA)
2522 strcat (buf, ", ledata");
2523
2524 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2525 strcat (buf, ", tso");
2526
2527 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2528 strcat (buf, ", pso");
2529
2530 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2531 strcat (buf, ", rmo");
2532 break;
7d466069 2533
103f02d3
UD		 2534 case EM_PARISC:
2535 switch (e_flags & EF_PARISC_ARCH)
2536 {
2537 case EFA_PARISC_1_0:
2538 strcpy (buf, ", PA-RISC 1.0");
2539 break;
2540 case EFA_PARISC_1_1:
2541 strcpy (buf, ", PA-RISC 1.1");
2542 break;
2543 case EFA_PARISC_2_0:
2544 strcpy (buf, ", PA-RISC 2.0");
2545 break;
2546 default:
2547 break;
2548 }
2549 if (e_flags & EF_PARISC_TRAPNIL)
2550 strcat (buf, ", trapnil");
2551 if (e_flags & EF_PARISC_EXT)
2552 strcat (buf, ", ext");
2553 if (e_flags & EF_PARISC_LSB)
2554 strcat (buf, ", lsb");
2555 if (e_flags & EF_PARISC_WIDE)
2556 strcat (buf, ", wide");
2557 if (e_flags & EF_PARISC_NO_KABP)
2558 strcat (buf, ", no kabp");
2559 if (e_flags & EF_PARISC_LAZYSWAP)
2560 strcat (buf, ", lazyswap");
30800947 2561 break;
76da6bbe 2562
7d466069 2563 case EM_PJ:
2b0337b0 2564 case EM_PJ_OLD:
7d466069
ILT		 2565 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2566 strcat (buf, ", new calling convention");
2567
2568 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2569 strcat (buf, ", gnu calling convention");
2570 break;
4d6ed7c8
NC		 2571
2572 case EM_IA_64:
2573 if ((e_flags & EF_IA_64_ABI64))
2574 strcat (buf, ", 64-bit");
2575 else
2576 strcat (buf, ", 32-bit");
2577 if ((e_flags & EF_IA_64_REDUCEDFP))
2578 strcat (buf, ", reduced fp model");
2579 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2580 strcat (buf, ", no function descriptors, constant gp");
2581 else if ((e_flags & EF_IA_64_CONS_GP))
2582 strcat (buf, ", constant gp");
2583 if ((e_flags & EF_IA_64_ABSOLUTE))
2584 strcat (buf, ", absolute");
28f997cf
TG		 2585 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2586 {
2587 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2588 strcat (buf, ", vms_linkages");
2589 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2590 {
2591 case EF_IA_64_VMS_COMCOD_SUCCESS:
2592 break;
2593 case EF_IA_64_VMS_COMCOD_WARNING:
2594 strcat (buf, ", warning");
2595 break;
2596 case EF_IA_64_VMS_COMCOD_ERROR:
2597 strcat (buf, ", error");
2598 break;
2599 case EF_IA_64_VMS_COMCOD_ABORT:
2600 strcat (buf, ", abort");
2601 break;
2602 default:
2603 abort ();
2604 }
2605 }
4d6ed7c8 2606 break;
179d3252
JT		 2607
2608 case EM_VAX:
2609 if ((e_flags & EF_VAX_NONPIC))
2610 strcat (buf, ", non-PIC");
2611 if ((e_flags & EF_VAX_DFLOAT))
2612 strcat (buf, ", D-Float");
2613 if ((e_flags & EF_VAX_GFLOAT))
2614 strcat (buf, ", G-Float");
2615 break;
c7927a3c
NC		 2616
2617 case EM_RX:
2618 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2619 strcat (buf, ", 64-bit doubles");
2620 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 2621 strcat (buf, ", dsp");
d4cb0ea0
NC		 2622 if (e_flags & E_FLAG_RX_PID)
2623 strcat (buf, ", pid");
2624 break;
55786da2
AK		 2625
2626 case EM_S390:
2627 if (e_flags & EF_S390_HIGH_GPRS)
2628 strcat (buf, ", highgprs");
d4cb0ea0 2629 break;
40b36596
JM		 2630
2631 case EM_TI_C6000:
2632 if ((e_flags & EF_C6000_REL))
2633 strcat (buf, ", relocatable module");
d4cb0ea0 2634 break;
252b5132
RH		 2635 }
2636 }
2637
2638 return buf;
2639}
2640
252b5132 2641static const char *
d3ba0551
AM		 2642get_osabi_name (unsigned int osabi)
2643{
2644 static char buff[32];
2645
2646 switch (osabi)
2647 {
2648 case ELFOSABI_NONE: return "UNIX - System V";
2649 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2650 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 2651 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 2652 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2653 case ELFOSABI_AIX: return "UNIX - AIX";
2654 case ELFOSABI_IRIX: return "UNIX - IRIX";
2655 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2656 case ELFOSABI_TRU64: return "UNIX - TRU64";
2657 case ELFOSABI_MODESTO: return "Novell - Modesto";
2658 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2659 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2660 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 2661 case ELFOSABI_AROS: return "AROS";
11636f9e 2662 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 2663 default:
40b36596
JM		 2664 if (osabi >= 64)
2665 switch (elf_header.e_machine)
2666 {
2667 case EM_ARM:
2668 switch (osabi)
2669 {
2670 case ELFOSABI_ARM: return "ARM";
2671 default:
2672 break;
2673 }
2674 break;
2675
2676 case EM_MSP430:
2677 case EM_MSP430_OLD:
2678 switch (osabi)
2679 {
2680 case ELFOSABI_STANDALONE: return _("Standalone App");
2681 default:
2682 break;
2683 }
2684 break;
2685
2686 case EM_TI_C6000:
2687 switch (osabi)
2688 {
2689 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2690 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2691 default:
2692 break;
2693 }
2694 break;
2695
2696 default:
2697 break;
2698 }
e9e44622 2699 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 2700 return buff;
2701 }
2702}
2703
a06ea964
NC		 2704static const char *
2705get_aarch64_segment_type (unsigned long type)
2706{
2707 switch (type)
2708 {
2709 case PT_AARCH64_ARCHEXT:
2710 return "AARCH64_ARCHEXT";
2711 default:
2712 break;
2713 }
2714
2715 return NULL;
2716}
2717
b294bdf8
MM		 2718static const char *
2719get_arm_segment_type (unsigned long type)
2720{
2721 switch (type)
2722 {
2723 case PT_ARM_EXIDX:
2724 return "EXIDX";
2725 default:
2726 break;
2727 }
2728
2729 return NULL;
2730}
2731
d3ba0551
AM		 2732static const char *
2733get_mips_segment_type (unsigned long type)
252b5132
RH		 2734{
2735 switch (type)
2736 {
2737 case PT_MIPS_REGINFO:
2738 return "REGINFO";
2739 case PT_MIPS_RTPROC:
2740 return "RTPROC";
2741 case PT_MIPS_OPTIONS:
2742 return "OPTIONS";
2743 default:
2744 break;
2745 }
2746
2747 return NULL;
2748}
2749
103f02d3 2750static const char *
d3ba0551 2751get_parisc_segment_type (unsigned long type)
103f02d3
UD		 2752{
2753 switch (type)
2754 {
2755 case PT_HP_TLS: return "HP_TLS";
2756 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2757 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2758 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2759 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2760 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2761 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2762 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2763 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2764 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2765 case PT_HP_PARALLEL: return "HP_PARALLEL";
2766 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 2767 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2768 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2769 case PT_HP_STACK: return "HP_STACK";
2770 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 2771 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2772 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 2773 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 2774 default:
2775 break;
2776 }
2777
2778 return NULL;
2779}
2780
4d6ed7c8 2781static const char *
d3ba0551 2782get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 2783{
2784 switch (type)
2785 {
2786 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2787 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 2788 case PT_HP_TLS: return "HP_TLS";
2789 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2790 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2791 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 2792 default:
2793 break;
2794 }
2795
2796 return NULL;
2797}
2798
40b36596
JM		 2799static const char *
2800get_tic6x_segment_type (unsigned long type)
2801{
2802 switch (type)
2803 {
2804 case PT_C6000_PHATTR: return "C6000_PHATTR";
2805 default:
2806 break;
2807 }
2808
2809 return NULL;
2810}
2811
252b5132 2812static const char *
d3ba0551 2813get_segment_type (unsigned long p_type)
252b5132 2814{
b34976b6 2815 static char buff[32];
252b5132
RH		 2816
2817 switch (p_type)
2818 {
b34976b6
AM		 2819 case PT_NULL: return "NULL";
2820 case PT_LOAD: return "LOAD";
252b5132 2821 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 2822 case PT_INTERP: return "INTERP";
2823 case PT_NOTE: return "NOTE";
2824 case PT_SHLIB: return "SHLIB";
2825 case PT_PHDR: return "PHDR";
13ae64f3 2826 case PT_TLS: return "TLS";
252b5132 2827
65765700
JJ		 2828 case PT_GNU_EH_FRAME:
2829 return "GNU_EH_FRAME";
2b05f1b7 2830 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 2831 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 2832
252b5132
RH		 2833 default:
2834 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2835 {
2cf0635d 2836 const char * result;
103f02d3 2837
252b5132
RH		 2838 switch (elf_header.e_machine)
2839 {
a06ea964
NC		 2840 case EM_AARCH64:
2841 result = get_aarch64_segment_type (p_type);
2842 break;
b294bdf8
MM		 2843 case EM_ARM:
2844 result = get_arm_segment_type (p_type);
2845 break;
252b5132 2846 case EM_MIPS:
4fe85591 2847 case EM_MIPS_RS3_LE:
252b5132
RH		 2848 result = get_mips_segment_type (p_type);
2849 break;
103f02d3
UD		 2850 case EM_PARISC:
2851 result = get_parisc_segment_type (p_type);
2852 break;
4d6ed7c8
NC		 2853 case EM_IA_64:
2854 result = get_ia64_segment_type (p_type);
2855 break;
40b36596
JM		 2856 case EM_TI_C6000:
2857 result = get_tic6x_segment_type (p_type);
2858 break;
252b5132
RH		 2859 default:
2860 result = NULL;
2861 break;
2862 }
103f02d3 2863
252b5132
RH		 2864 if (result != NULL)
2865 return result;
103f02d3 2866
252b5132
RH		 2867 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2868 }
2869 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 2870 {
2cf0635d 2871 const char * result;
103f02d3
UD		 2872
2873 switch (elf_header.e_machine)
2874 {
2875 case EM_PARISC:
2876 result = get_parisc_segment_type (p_type);
2877 break;
00428cca
AM		 2878 case EM_IA_64:
2879 result = get_ia64_segment_type (p_type);
2880 break;
103f02d3
UD		 2881 default:
2882 result = NULL;
2883 break;
2884 }
2885
2886 if (result != NULL)
2887 return result;
2888
2889 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2890 }
252b5132 2891 else
e9e44622 2892 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 2893
2894 return buff;
2895 }
2896}
2897
2898static const char *
d3ba0551 2899get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 2900{
2901 switch (sh_type)
2902 {
b34976b6
AM		 2903 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2904 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2905 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2906 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2907 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2908 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2909 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2910 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2911 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2912 case SHT_MIPS_RELD: return "MIPS_RELD";
2913 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2914 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2915 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2916 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2917 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2918 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2919 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2920 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2921 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2922 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2923 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2924 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2925 case SHT_MIPS_LINE: return "MIPS_LINE";
2926 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2927 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2928 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2929 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2930 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2931 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2932 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2933 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2934 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2935 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2936 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2937 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2938 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2939 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2940 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132
RH		 2941 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2942 default:
2943 break;
2944 }
2945 return NULL;
2946}
2947
103f02d3 2948static const char *
d3ba0551 2949get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 2950{
2951 switch (sh_type)
2952 {
2953 case SHT_PARISC_EXT: return "PARISC_EXT";
2954 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2955 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 2956 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2957 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2958 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 2959 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 2960 default:
2961 break;
2962 }
2963 return NULL;
2964}
2965
4d6ed7c8 2966static const char *
d3ba0551 2967get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 2968{
18bd398b 2969 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 2970 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2971 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 2972
4d6ed7c8
NC		 2973 switch (sh_type)
2974 {
148b93f2
NC		 2975 case SHT_IA_64_EXT: return "IA_64_EXT";
2976 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2977 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2978 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2979 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2980 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2981 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2982 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2983 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2984 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 2985 default:
2986 break;
2987 }
2988 return NULL;
2989}
2990
d2b2c203
DJ		 2991static const char *
2992get_x86_64_section_type_name (unsigned int sh_type)
2993{
2994 switch (sh_type)
2995 {
2996 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2997 default:
2998 break;
2999 }
3000 return NULL;
3001}
3002
a06ea964
NC		 3003static const char *
3004get_aarch64_section_type_name (unsigned int sh_type)
3005{
3006 switch (sh_type)
3007 {
3008 case SHT_AARCH64_ATTRIBUTES:
3009 return "AARCH64_ATTRIBUTES";
3010 default:
3011 break;
3012 }
3013 return NULL;
3014}
3015
40a18ebd
NC		 3016static const char *
3017get_arm_section_type_name (unsigned int sh_type)
3018{
3019 switch (sh_type)
3020 {
7f6fed87
NC		 3021 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3022 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3023 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3024 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3025 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3026 default:
3027 break;
3028 }
3029 return NULL;
3030}
3031
40b36596
JM		 3032static const char *
3033get_tic6x_section_type_name (unsigned int sh_type)
3034{
3035 switch (sh_type)
3036 {
3037 case SHT_C6000_UNWIND:
3038 return "C6000_UNWIND";
3039 case SHT_C6000_PREEMPTMAP:
3040 return "C6000_PREEMPTMAP";
3041 case SHT_C6000_ATTRIBUTES:
3042 return "C6000_ATTRIBUTES";
3043 case SHT_TI_ICODE:
3044 return "TI_ICODE";
3045 case SHT_TI_XREF:
3046 return "TI_XREF";
3047 case SHT_TI_HANDLER:
3048 return "TI_HANDLER";
3049 case SHT_TI_INITINFO:
3050 return "TI_INITINFO";
3051 case SHT_TI_PHATTRS:
3052 return "TI_PHATTRS";
3053 default:
3054 break;
3055 }
3056 return NULL;
3057}
3058
252b5132 3059static const char *
d3ba0551 3060get_section_type_name (unsigned int sh_type)
252b5132 3061{
b34976b6 3062 static char buff[32];
252b5132
RH		 3063
3064 switch (sh_type)
3065 {
3066 case SHT_NULL: return "NULL";
3067 case SHT_PROGBITS: return "PROGBITS";
3068 case SHT_SYMTAB: return "SYMTAB";
3069 case SHT_STRTAB: return "STRTAB";
3070 case SHT_RELA: return "RELA";
3071 case SHT_HASH: return "HASH";
3072 case SHT_DYNAMIC: return "DYNAMIC";
3073 case SHT_NOTE: return "NOTE";
3074 case SHT_NOBITS: return "NOBITS";
3075 case SHT_REL: return "REL";
3076 case SHT_SHLIB: return "SHLIB";
3077 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3078 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3079 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3080 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3081 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3082 case SHT_GROUP: return "GROUP";
3083 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3084 case SHT_GNU_verdef: return "VERDEF";
3085 case SHT_GNU_verneed: return "VERNEED";
3086 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3087 case 0x6ffffff0: return "VERSYM";
3088 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3089 case 0x7ffffffd: return "AUXILIARY";
3090 case 0x7fffffff: return "FILTER";
047b2264 3091 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3092
3093 default:
3094 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3095 {
2cf0635d 3096 const char * result;
252b5132
RH		 3097
3098 switch (elf_header.e_machine)
3099 {
3100 case EM_MIPS:
4fe85591 3101 case EM_MIPS_RS3_LE:
252b5132
RH		 3102 result = get_mips_section_type_name (sh_type);
3103 break;
103f02d3
UD		 3104 case EM_PARISC:
3105 result = get_parisc_section_type_name (sh_type);
3106 break;
4d6ed7c8
NC		 3107 case EM_IA_64:
3108 result = get_ia64_section_type_name (sh_type);
3109 break;
d2b2c203 3110 case EM_X86_64:
8a9036a4 3111 case EM_L1OM:
7a9068fe 3112 case EM_K1OM:
d2b2c203
DJ		 3113 result = get_x86_64_section_type_name (sh_type);
3114 break;
a06ea964
NC		 3115 case EM_AARCH64:
3116 result = get_aarch64_section_type_name (sh_type);
3117 break;
40a18ebd
NC		 3118 case EM_ARM:
3119 result = get_arm_section_type_name (sh_type);
3120 break;
40b36596
JM		 3121 case EM_TI_C6000:
3122 result = get_tic6x_section_type_name (sh_type);
3123 break;
252b5132
RH		 3124 default:
3125 result = NULL;
3126 break;
3127 }
3128
3129 if (result != NULL)
3130 return result;
3131
c91d0dfb 3132 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3133 }
3134 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3135 {
2cf0635d 3136 const char * result;
148b93f2
NC		 3137
3138 switch (elf_header.e_machine)
3139 {
3140 case EM_IA_64:
3141 result = get_ia64_section_type_name (sh_type);
3142 break;
3143 default:
3144 result = NULL;
3145 break;
3146 }
3147
3148 if (result != NULL)
3149 return result;
3150
3151 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3152 }
252b5132 3153 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
c91d0dfb 3154 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
252b5132 3155 else
a7dbfd1c
NC		 3156 /* This message is probably going to be displayed in a 15
3157 character wide field, so put the hex value first. */
3158 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3159
252b5132
RH		 3160 return buff;
3161 }
3162}
3163
2979dc34 3164#define OPTION_DEBUG_DUMP 512
2c610e4b 3165#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3166#define OPTION_DWARF_DEPTH 514
3167#define OPTION_DWARF_START 515
4723351a 3168#define OPTION_DWARF_CHECK 516
2979dc34 3169
85b1c36d 3170static struct option options[] =
252b5132 3171{
b34976b6 3172 {"all", no_argument, 0, 'a'},
252b5132
RH		 3173 {"file-header", no_argument, 0, 'h'},
3174 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 3175 {"headers", no_argument, 0, 'e'},
3176 {"histogram", no_argument, 0, 'I'},
3177 {"segments", no_argument, 0, 'l'},
3178 {"sections", no_argument, 0, 'S'},
252b5132 3179 {"section-headers", no_argument, 0, 'S'},
f5842774 3180 {"section-groups", no_argument, 0, 'g'},
5477e8a0 3181 {"section-details", no_argument, 0, 't'},
595cf52e 3182 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 3183 {"symbols", no_argument, 0, 's'},
3184 {"syms", no_argument, 0, 's'},
2c610e4b 3185 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 3186 {"relocs", no_argument, 0, 'r'},
3187 {"notes", no_argument, 0, 'n'},
3188 {"dynamic", no_argument, 0, 'd'},
a952a375 3189 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 3190 {"version-info", no_argument, 0, 'V'},
3191 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 3192 {"unwind", no_argument, 0, 'u'},
4145f1d5 3193 {"archive-index", no_argument, 0, 'c'},
b34976b6 3194 {"hex-dump", required_argument, 0, 'x'},
cf13d699 3195 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 3196 {"string-dump", required_argument, 0, 'p'},
252b5132
RH		 3197#ifdef SUPPORT_DISASSEMBLY
3198 {"instruction-dump", required_argument, 0, 'i'},
3199#endif
cf13d699 3200 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 3201
fd2f0033
TT		 3202 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3203 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 3204 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 3205
b34976b6
AM		 3206 {"version", no_argument, 0, 'v'},
3207 {"wide", no_argument, 0, 'W'},
3208 {"help", no_argument, 0, 'H'},
3209 {0, no_argument, 0, 0}
252b5132
RH		 3210};
3211
3212static void
2cf0635d 3213usage (FILE * stream)
252b5132 3214{
92f01d61
JM		 3215 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3216 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3217 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 3218 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3219 -h --file-header Display the ELF file header\n\
3220 -l --program-headers Display the program headers\n\
3221 --segments An alias for --program-headers\n\
3222 -S --section-headers Display the sections' header\n\
3223 --sections An alias for --section-headers\n\
f5842774 3224 -g --section-groups Display the section groups\n\
5477e8a0 3225 -t --section-details Display the section details\n\
8b53311e
NC		 3226 -e --headers Equivalent to: -h -l -S\n\
3227 -s --syms Display the symbol table\n\
3f08eb35 3228 --symbols An alias for --syms\n\
2c610e4b 3229 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 3230 -n --notes Display the core notes (if present)\n\
3231 -r --relocs Display the relocations (if present)\n\
3232 -u --unwind Display the unwind info (if present)\n\
b2d38a17 3233 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 3234 -V --version-info Display the version sections (if present)\n\
1b31d05e 3235 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 3236 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 3237 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 3238 -x --hex-dump=<number|name>\n\
3239 Dump the contents of section <number|name> as bytes\n\
3240 -p --string-dump=<number|name>\n\
3241 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 3242 -R --relocated-dump=<number|name>\n\
3243 Dump the contents of section <number|name> as relocated bytes\n\
f9f0e732 3244 -w[lLiaprmfFsoRt] or\n\
1ed06042 3245 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 3246 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
5bbdf3d5 3247 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
8b53311e 3248 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 3249 fprintf (stream, _("\
3250 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3251 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3252 or deeper\n"));
252b5132 3253#ifdef SUPPORT_DISASSEMBLY
92f01d61 3254 fprintf (stream, _("\
09c11c86
NC		 3255 -i --instruction-dump=<number|name>\n\
3256 Disassemble the contents of section <number|name>\n"));
252b5132 3257#endif
92f01d61 3258 fprintf (stream, _("\
8b53311e
NC		 3259 -I --histogram Display histogram of bucket list lengths\n\
3260 -W --wide Allow output width to exceed 80 characters\n\
07012eee 3261 @<file> Read options from <file>\n\
8b53311e
NC		 3262 -H --help Display this information\n\
3263 -v --version Display the version number of readelf\n"));
1118d252 3264
92f01d61
JM		 3265 if (REPORT_BUGS_TO[0] && stream == stdout)
3266 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 3267
92f01d61 3268 exit (stream == stdout ? 0 : 1);
252b5132
RH		 3269}
3270
18bd398b
NC		 3271/* Record the fact that the user wants the contents of section number
3272 SECTION to be displayed using the method(s) encoded as flags bits
3273 in TYPE. Note, TYPE can be zero if we are creating the array for
3274 the first time. */
3275
252b5132 3276static void
09c11c86 3277request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 3278{
3279 if (section >= num_dump_sects)
3280 {
2cf0635d 3281 dump_type * new_dump_sects;
252b5132 3282
3f5e193b
NC		 3283 new_dump_sects = (dump_type *) calloc (section + 1,
3284 sizeof (* dump_sects));
252b5132
RH		 3285
3286 if (new_dump_sects == NULL)
591a748a 3287 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 3288 else
3289 {
3290 /* Copy current flag settings. */
09c11c86 3291 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 3292
3293 free (dump_sects);
3294
3295 dump_sects = new_dump_sects;
3296 num_dump_sects = section + 1;
3297 }
3298 }
3299
3300 if (dump_sects)
b34976b6 3301 dump_sects[section] |= type;
252b5132
RH		 3302
3303 return;
3304}
3305
aef1f6d0
DJ		 3306/* Request a dump by section name. */
3307
3308static void
2cf0635d 3309request_dump_byname (const char * section, dump_type type)
aef1f6d0 3310{
2cf0635d 3311 struct dump_list_entry * new_request;
aef1f6d0 3312
3f5e193b
NC		 3313 new_request = (struct dump_list_entry *)
3314 malloc (sizeof (struct dump_list_entry));
aef1f6d0 3315 if (!new_request)
591a748a 3316 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3317
3318 new_request->name = strdup (section);
3319 if (!new_request->name)
591a748a 3320 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 3321
3322 new_request->type = type;
3323
3324 new_request->next = dump_sects_byname;
3325 dump_sects_byname = new_request;
3326}
3327
cf13d699
NC		 3328static inline void
3329request_dump (dump_type type)
3330{
3331 int section;
3332 char * cp;
3333
3334 do_dump++;
3335 section = strtoul (optarg, & cp, 0);
3336
3337 if (! *cp && section >= 0)
3338 request_dump_bynumber (section, type);
3339 else
3340 request_dump_byname (optarg, type);
3341}
3342
3343
252b5132 3344static void
2cf0635d 3345parse_args (int argc, char ** argv)
252b5132
RH		 3346{
3347 int c;
3348
3349 if (argc < 2)
92f01d61 3350 usage (stderr);
252b5132
RH		 3351
3352 while ((c = getopt_long
cf13d699 3353 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
252b5132 3354 {
252b5132
RH		 3355 switch (c)
3356 {
3357 case 0:
3358 /* Long options. */
3359 break;
3360 case 'H':
92f01d61 3361 usage (stdout);
252b5132
RH		 3362 break;
3363
3364 case 'a':
b34976b6
AM		 3365 do_syms++;
3366 do_reloc++;
3367 do_unwind++;
3368 do_dynamic++;
3369 do_header++;
3370 do_sections++;
f5842774 3371 do_section_groups++;
b34976b6
AM		 3372 do_segments++;
3373 do_version++;
3374 do_histogram++;
3375 do_arch++;
3376 do_notes++;
252b5132 3377 break;
f5842774
L		 3378 case 'g':
3379 do_section_groups++;
3380 break;
5477e8a0 3381 case 't':
595cf52e 3382 case 'N':
5477e8a0
L		 3383 do_sections++;
3384 do_section_details++;
595cf52e 3385 break;
252b5132 3386 case 'e':
b34976b6
AM		 3387 do_header++;
3388 do_sections++;
3389 do_segments++;
252b5132 3390 break;
a952a375 3391 case 'A':
b34976b6 3392 do_arch++;
a952a375 3393 break;
252b5132 3394 case 'D':
b34976b6 3395 do_using_dynamic++;
252b5132
RH		 3396 break;
3397 case 'r':
b34976b6 3398 do_reloc++;
252b5132 3399 break;
4d6ed7c8 3400 case 'u':
b34976b6 3401 do_unwind++;
4d6ed7c8 3402 break;
252b5132 3403 case 'h':
b34976b6 3404 do_header++;
252b5132
RH		 3405 break;
3406 case 'l':
b34976b6 3407 do_segments++;
252b5132
RH		 3408 break;
3409 case 's':
b34976b6 3410 do_syms++;
252b5132
RH		 3411 break;
3412 case 'S':
b34976b6 3413 do_sections++;
252b5132
RH		 3414 break;
3415 case 'd':
b34976b6 3416 do_dynamic++;
252b5132 3417 break;
a952a375 3418 case 'I':
b34976b6 3419 do_histogram++;
a952a375 3420 break;
779fe533 3421 case 'n':
b34976b6 3422 do_notes++;
779fe533 3423 break;
4145f1d5
NC		 3424 case 'c':
3425 do_archive_index++;
3426 break;
252b5132 3427 case 'x':
cf13d699 3428 request_dump (HEX_DUMP);
aef1f6d0 3429 break;
09c11c86 3430 case 'p':
cf13d699
NC		 3431 request_dump (STRING_DUMP);
3432 break;
3433 case 'R':
3434 request_dump (RELOC_DUMP);
09c11c86 3435 break;
252b5132 3436 case 'w':
b34976b6 3437 do_dump++;
252b5132 3438 if (optarg == 0)
613ff48b
CC		 3439 {
3440 do_debugging = 1;
3441 dwarf_select_sections_all ();
3442 }
252b5132
RH		 3443 else
3444 {
3445 do_debugging = 0;
4cb93e3b 3446 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 3447 }
3448 break;
2979dc34 3449 case OPTION_DEBUG_DUMP:
b34976b6 3450 do_dump++;
2979dc34
JJ		 3451 if (optarg == 0)
3452 do_debugging = 1;
3453 else
3454 {
2979dc34 3455 do_debugging = 0;
4cb93e3b 3456 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 3457 }
3458 break;
fd2f0033
TT		 3459 case OPTION_DWARF_DEPTH:
3460 {
3461 char *cp;
3462
3463 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3464 }
3465 break;
3466 case OPTION_DWARF_START:
3467 {
3468 char *cp;
3469
3470 dwarf_start_die = strtoul (optarg, & cp, 0);
3471 }
3472 break;
4723351a
CC		 3473 case OPTION_DWARF_CHECK:
3474 dwarf_check = 1;
3475 break;
2c610e4b
L		 3476 case OPTION_DYN_SYMS:
3477 do_dyn_syms++;
3478 break;
252b5132
RH		 3479#ifdef SUPPORT_DISASSEMBLY
3480 case 'i':
cf13d699
NC		 3481 request_dump (DISASS_DUMP);
3482 break;
252b5132
RH		 3483#endif
3484 case 'v':
3485 print_version (program_name);
3486 break;
3487 case 'V':
b34976b6 3488 do_version++;
252b5132 3489 break;
d974e256 3490 case 'W':
b34976b6 3491 do_wide++;
d974e256 3492 break;
252b5132 3493 default:
252b5132
RH		 3494 /* xgettext:c-format */
3495 error (_("Invalid option '-%c'\n"), c);
3496 /* Drop through. */
3497 case '?':
92f01d61 3498 usage (stderr);
252b5132
RH		 3499 }
3500 }
3501
4d6ed7c8 3502 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 3503 && !do_segments && !do_header && !do_dump && !do_version
f5842774 3504 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 3505 && !do_section_groups && !do_archive_index
3506 && !do_dyn_syms)
92f01d61 3507 usage (stderr);
252b5132
RH		 3508 else if (argc < 3)
3509 {
3510 warn (_("Nothing to do.\n"));
92f01d61 3511 usage (stderr);
252b5132
RH		 3512 }
3513}
3514
3515static const char *
d3ba0551 3516get_elf_class (unsigned int elf_class)
252b5132 3517{
b34976b6 3518 static char buff[32];
103f02d3 3519
252b5132
RH		 3520 switch (elf_class)
3521 {
3522 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 3523 case ELFCLASS32: return "ELF32";
3524 case ELFCLASS64: return "ELF64";
ab5e7794 3525 default:
e9e44622 3526 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 3527 return buff;
252b5132
RH		 3528 }
3529}
3530
3531static const char *
d3ba0551 3532get_data_encoding (unsigned int encoding)
252b5132 3533{
b34976b6 3534 static char buff[32];
103f02d3 3535
252b5132
RH		 3536 switch (encoding)
3537 {
3538 case ELFDATANONE: return _("none");
33c63f9d
CM		 3539 case ELFDATA2LSB: return _("2's complement, little endian");
3540 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 3541 default:
e9e44622 3542 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 3543 return buff;
252b5132
RH		 3544 }
3545}
3546
252b5132 3547/* Decode the data held in 'elf_header'. */
ee42cf8c 3548
252b5132 3549static int
d3ba0551 3550process_file_header (void)
252b5132 3551{
b34976b6
AM		 3552 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3553 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3554 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3555 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 3556 {
3557 error
3558 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3559 return 0;
3560 }
3561
2dc4cec1
L		 3562 init_dwarf_regnames (elf_header.e_machine);
3563
252b5132
RH		 3564 if (do_header)
3565 {
3566 int i;
3567
3568 printf (_("ELF Header:\n"));
3569 printf (_(" Magic: "));
b34976b6
AM		 3570 for (i = 0; i < EI_NIDENT; i++)
3571 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 3572 printf ("\n");
3573 printf (_(" Class: %s\n"),
b34976b6 3574 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 3575 printf (_(" Data: %s\n"),
b34976b6 3576 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 3577 printf (_(" Version: %d %s\n"),
b34976b6
AM		 3578 elf_header.e_ident[EI_VERSION],
3579 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 3580 ? "(current)"
b34976b6 3581 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 3582 ? _("<unknown: %lx>")
789be9f7 3583 : "")));
252b5132 3584 printf (_(" OS/ABI: %s\n"),
b34976b6 3585 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 3586 printf (_(" ABI Version: %d\n"),
b34976b6 3587 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 3588 printf (_(" Type: %s\n"),
3589 get_file_type (elf_header.e_type));
3590 printf (_(" Machine: %s\n"),
3591 get_machine_name (elf_header.e_machine));
3592 printf (_(" Version: 0x%lx\n"),
3593 (unsigned long) elf_header.e_version);
76da6bbe 3594
f7a99963
NC		 3595 printf (_(" Entry point address: "));
3596 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3597 printf (_("\n Start of program headers: "));
3598 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3599 printf (_(" (bytes into file)\n Start of section headers: "));
3600 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3601 printf (_(" (bytes into file)\n"));
76da6bbe 3602
252b5132
RH		 3603 printf (_(" Flags: 0x%lx%s\n"),
3604 (unsigned long) elf_header.e_flags,
3605 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3606 printf (_(" Size of this header: %ld (bytes)\n"),
3607 (long) elf_header.e_ehsize);
3608 printf (_(" Size of program headers: %ld (bytes)\n"),
3609 (long) elf_header.e_phentsize);
2046a35d 3610 printf (_(" Number of program headers: %ld"),
252b5132 3611 (long) elf_header.e_phnum);
2046a35d
AM		 3612 if (section_headers != NULL
3613 && elf_header.e_phnum == PN_XNUM
3614 && section_headers[0].sh_info != 0)
cc5914eb 3615 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 3616 putc ('\n', stdout);
252b5132
RH		 3617 printf (_(" Size of section headers: %ld (bytes)\n"),
3618 (long) elf_header.e_shentsize);
560f3c1c 3619 printf (_(" Number of section headers: %ld"),
252b5132 3620 (long) elf_header.e_shnum);
4fbb74a6 3621 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 3622 printf (" (%ld)", (long) section_headers[0].sh_size);
3623 putc ('\n', stdout);
3624 printf (_(" Section header string table index: %ld"),
252b5132 3625 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 3626 if (section_headers != NULL
3627 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 3628 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 3629 else if (elf_header.e_shstrndx != SHN_UNDEF
3630 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 3631 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 3632 putc ('\n', stdout);
3633 }
3634
3635 if (section_headers != NULL)
3636 {
2046a35d
AM		 3637 if (elf_header.e_phnum == PN_XNUM
3638 && section_headers[0].sh_info != 0)
3639 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 3640 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 3641 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 3642 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 3643 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 3644 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 3645 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 3646 free (section_headers);
3647 section_headers = NULL;
252b5132 3648 }
103f02d3 3649
9ea033b2
NC		 3650 return 1;
3651}
3652
252b5132 3653
9ea033b2 3654static int
91d6fa6a 3655get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3656{
2cf0635d
NC		 3657 Elf32_External_Phdr * phdrs;
3658 Elf32_External_Phdr * external;
3659 Elf_Internal_Phdr * internal;
b34976b6 3660 unsigned int i;
103f02d3 3661
3f5e193b
NC		 3662 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3663 elf_header.e_phentsize,
3664 elf_header.e_phnum,
3665 _("program headers"));
a6e9f9df
AM		 3666 if (!phdrs)
3667 return 0;
9ea033b2 3668
91d6fa6a 3669 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3670 i < elf_header.e_phnum;
b34976b6 3671 i++, internal++, external++)
252b5132 3672 {
9ea033b2
NC		 3673 internal->p_type = BYTE_GET (external->p_type);
3674 internal->p_offset = BYTE_GET (external->p_offset);
3675 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3676 internal->p_paddr = BYTE_GET (external->p_paddr);
3677 internal->p_filesz = BYTE_GET (external->p_filesz);
3678 internal->p_memsz = BYTE_GET (external->p_memsz);
3679 internal->p_flags = BYTE_GET (external->p_flags);
3680 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 3681 }
3682
9ea033b2
NC		 3683 free (phdrs);
3684
252b5132
RH		 3685 return 1;
3686}
3687
9ea033b2 3688static int
91d6fa6a 3689get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 3690{
2cf0635d
NC		 3691 Elf64_External_Phdr * phdrs;
3692 Elf64_External_Phdr * external;
3693 Elf_Internal_Phdr * internal;
b34976b6 3694 unsigned int i;
103f02d3 3695
3f5e193b
NC		 3696 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3697 elf_header.e_phentsize,
3698 elf_header.e_phnum,
3699 _("program headers"));
a6e9f9df
AM		 3700 if (!phdrs)
3701 return 0;
9ea033b2 3702
91d6fa6a 3703 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 3704 i < elf_header.e_phnum;
b34976b6 3705 i++, internal++, external++)
9ea033b2
NC		 3706 {
3707 internal->p_type = BYTE_GET (external->p_type);
3708 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 3709 internal->p_offset = BYTE_GET (external->p_offset);
3710 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3711 internal->p_paddr = BYTE_GET (external->p_paddr);
3712 internal->p_filesz = BYTE_GET (external->p_filesz);
3713 internal->p_memsz = BYTE_GET (external->p_memsz);
3714 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 3715 }
3716
3717 free (phdrs);
3718
3719 return 1;
3720}
252b5132 3721
d93f0186
NC		 3722/* Returns 1 if the program headers were read into `program_headers'. */
3723
3724static int
2cf0635d 3725get_program_headers (FILE * file)
d93f0186 3726{
2cf0635d 3727 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 3728
3729 /* Check cache of prior read. */
3730 if (program_headers != NULL)
3731 return 1;
3732
3f5e193b
NC		 3733 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3734 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 3735
3736 if (phdrs == NULL)
3737 {
3738 error (_("Out of memory\n"));
3739 return 0;
3740 }
3741
3742 if (is_32bit_elf
3743 ? get_32bit_program_headers (file, phdrs)
3744 : get_64bit_program_headers (file, phdrs))
3745 {
3746 program_headers = phdrs;
3747 return 1;
3748 }
3749
3750 free (phdrs);
3751 return 0;
3752}
3753
2f62977e
NC		 3754/* Returns 1 if the program headers were loaded. */
3755
252b5132 3756static int
2cf0635d 3757process_program_headers (FILE * file)
252b5132 3758{
2cf0635d 3759 Elf_Internal_Phdr * segment;
b34976b6 3760 unsigned int i;
252b5132
RH		 3761
3762 if (elf_header.e_phnum == 0)
3763 {
82f2dbf7
NC		 3764 /* PR binutils/12467. */
3765 if (elf_header.e_phoff != 0)
3766 warn (_("possibly corrupt ELF header - it has a non-zero program"
3767 " header offset, but no program headers"));
3768 else if (do_segments)
252b5132 3769 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 3770 return 0;
252b5132
RH		 3771 }
3772
3773 if (do_segments && !do_header)
3774 {
f7a99963
NC		 3775 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3776 printf (_("Entry point "));
3777 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3778 printf (_("\nThere are %d program headers, starting at offset "),
3779 elf_header.e_phnum);
3780 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3781 printf ("\n");
252b5132
RH		 3782 }
3783
d93f0186 3784 if (! get_program_headers (file))
252b5132 3785 return 0;
103f02d3 3786
252b5132
RH		 3787 if (do_segments)
3788 {
3a1a2036
NC		 3789 if (elf_header.e_phnum > 1)
3790 printf (_("\nProgram Headers:\n"));
3791 else
3792 printf (_("\nProgram Headers:\n"));
76da6bbe 3793
f7a99963
NC		 3794 if (is_32bit_elf)
3795 printf
3796 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 3797 else if (do_wide)
3798 printf
3799 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 3800 else
3801 {
3802 printf
3803 (_(" Type Offset VirtAddr PhysAddr\n"));
3804 printf
3805 (_(" FileSiz MemSiz Flags Align\n"));
3806 }
252b5132
RH		 3807 }
3808
252b5132 3809 dynamic_addr = 0;
1b228002 3810 dynamic_size = 0;
252b5132
RH		 3811
3812 for (i = 0, segment = program_headers;
3813 i < elf_header.e_phnum;
b34976b6 3814 i++, segment++)
252b5132
RH		 3815 {
3816 if (do_segments)
3817 {
103f02d3 3818 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 3819
3820 if (is_32bit_elf)
3821 {
3822 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3823 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3824 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3825 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3826 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3827 printf ("%c%c%c ",
3828 (segment->p_flags & PF_R ? 'R' : ' '),
3829 (segment->p_flags & PF_W ? 'W' : ' '),
3830 (segment->p_flags & PF_X ? 'E' : ' '));
3831 printf ("%#lx", (unsigned long) segment->p_align);
3832 }
d974e256
JJ		 3833 else if (do_wide)
3834 {
3835 if ((unsigned long) segment->p_offset == segment->p_offset)
3836 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3837 else
3838 {
3839 print_vma (segment->p_offset, FULL_HEX);
3840 putchar (' ');
3841 }
3842
3843 print_vma (segment->p_vaddr, FULL_HEX);
3844 putchar (' ');
3845 print_vma (segment->p_paddr, FULL_HEX);
3846 putchar (' ');
3847
3848 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3849 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3850 else
3851 {
3852 print_vma (segment->p_filesz, FULL_HEX);
3853 putchar (' ');
3854 }
3855
3856 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3857 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3858 else
3859 {
f48e6c45 3860 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 3861 }
3862
3863 printf (" %c%c%c ",
3864 (segment->p_flags & PF_R ? 'R' : ' '),
3865 (segment->p_flags & PF_W ? 'W' : ' '),
3866 (segment->p_flags & PF_X ? 'E' : ' '));
3867
3868 if ((unsigned long) segment->p_align == segment->p_align)
3869 printf ("%#lx", (unsigned long) segment->p_align);
3870 else
3871 {
3872 print_vma (segment->p_align, PREFIX_HEX);
3873 }
3874 }
f7a99963
NC		 3875 else
3876 {
3877 print_vma (segment->p_offset, FULL_HEX);
3878 putchar (' ');
3879 print_vma (segment->p_vaddr, FULL_HEX);
3880 putchar (' ');
3881 print_vma (segment->p_paddr, FULL_HEX);
3882 printf ("\n ");
3883 print_vma (segment->p_filesz, FULL_HEX);
3884 putchar (' ');
3885 print_vma (segment->p_memsz, FULL_HEX);
3886 printf (" %c%c%c ",
3887 (segment->p_flags & PF_R ? 'R' : ' '),
3888 (segment->p_flags & PF_W ? 'W' : ' '),
3889 (segment->p_flags & PF_X ? 'E' : ' '));
3890 print_vma (segment->p_align, HEX);
3891 }
252b5132
RH		 3892 }
3893
3894 switch (segment->p_type)
3895 {
252b5132
RH		 3896 case PT_DYNAMIC:
3897 if (dynamic_addr)
3898 error (_("more than one dynamic segment\n"));
3899
20737c13
AM		 3900 /* By default, assume that the .dynamic section is the first
3901 section in the DYNAMIC segment. */
3902 dynamic_addr = segment->p_offset;
3903 dynamic_size = segment->p_filesz;
3904
b2d38a17
NC		 3905 /* Try to locate the .dynamic section. If there is
3906 a section header table, we can easily locate it. */
3907 if (section_headers != NULL)
3908 {
2cf0635d 3909 Elf_Internal_Shdr * sec;
b2d38a17 3910
89fac5e3
RS		 3911 sec = find_section (".dynamic");
3912 if (sec == NULL || sec->sh_size == 0)
b2d38a17 3913 {
28f997cf
TG		 3914 /* A corresponding .dynamic section is expected, but on
3915 IA-64/OpenVMS it is OK for it to be missing. */
3916 if (!is_ia64_vms ())
3917 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 3918 break;
3919 }
3920
42bb2e33 3921 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 3922 {
3923 dynamic_size = 0;
3924 break;
3925 }
42bb2e33 3926
b2d38a17
NC		 3927 dynamic_addr = sec->sh_offset;
3928 dynamic_size = sec->sh_size;
3929
3930 if (dynamic_addr < segment->p_offset
3931 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 3932 warn (_("the .dynamic section is not contained"
3933 " within the dynamic segment\n"));
b2d38a17 3934 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 3935 warn (_("the .dynamic section is not the first section"
3936 " in the dynamic segment.\n"));
b2d38a17 3937 }
252b5132
RH		 3938 break;
3939
3940 case PT_INTERP:
fb52b2f4
NC		 3941 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3942 SEEK_SET))
252b5132
RH		 3943 error (_("Unable to find program interpreter name\n"));
3944 else
3945 {
f8eae8b2
L		 3946 char fmt [32];
3947 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3948
3949 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 3950 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 3951
252b5132 3952 program_interpreter[0] = 0;
7bd7b3ef
AM		 3953 if (fscanf (file, fmt, program_interpreter) <= 0)
3954 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 3955
3956 if (do_segments)
3957 printf (_("\n [Requesting program interpreter: %s]"),
3958 program_interpreter);
3959 }
3960 break;
3961 }
3962
3963 if (do_segments)
3964 putc ('\n', stdout);
3965 }
3966
c256ffe7 3967 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 3968 {
3969 printf (_("\n Section to Segment mapping:\n"));
3970 printf (_(" Segment Sections...\n"));
3971
252b5132
RH		 3972 for (i = 0; i < elf_header.e_phnum; i++)
3973 {
9ad5cbcf 3974 unsigned int j;
2cf0635d 3975 Elf_Internal_Shdr * section;
252b5132
RH		 3976
3977 segment = program_headers + i;
b391a3e3 3978 section = section_headers + 1;
252b5132
RH		 3979
3980 printf (" %2.2d ", i);
3981
b34976b6 3982 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 3983 {
f4638467
AM		 3984 if (!ELF_TBSS_SPECIAL (section, segment)
3985 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
252b5132
RH		 3986 printf ("%s ", SECTION_NAME (section));
3987 }
3988
3989 putc ('\n',stdout);
3990 }
3991 }
3992
252b5132
RH		 3993 return 1;
3994}
3995
3996
d93f0186
NC		 3997/* Find the file offset corresponding to VMA by using the program headers. */
3998
3999static long
2cf0635d 4000offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4001{
2cf0635d 4002 Elf_Internal_Phdr * seg;
d93f0186
NC		 4003
4004 if (! get_program_headers (file))
4005 {
4006 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4007 return (long) vma;
4008 }
4009
4010 for (seg = program_headers;
4011 seg < program_headers + elf_header.e_phnum;
4012 ++seg)
4013 {
4014 if (seg->p_type != PT_LOAD)
4015 continue;
4016
4017 if (vma >= (seg->p_vaddr & -seg->p_align)
4018 && vma + size <= seg->p_vaddr + seg->p_filesz)
4019 return vma - seg->p_vaddr + seg->p_offset;
4020 }
4021
4022 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4023 (unsigned long) vma);
d93f0186
NC		 4024 return (long) vma;
4025}
4026
4027
252b5132 4028static int
2cf0635d 4029get_32bit_section_headers (FILE * file, unsigned int num)
252b5132 4030{
2cf0635d
NC		 4031 Elf32_External_Shdr * shdrs;
4032 Elf_Internal_Shdr * internal;
b34976b6 4033 unsigned int i;
252b5132 4034
3f5e193b
NC		 4035 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4036 elf_header.e_shentsize, num,
4037 _("section headers"));
a6e9f9df
AM		 4038 if (!shdrs)
4039 return 0;
252b5132 4040
3f5e193b
NC		 4041 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4042 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4043
4044 if (section_headers == NULL)
4045 {
4046 error (_("Out of memory\n"));
4047 return 0;
4048 }
4049
4050 for (i = 0, internal = section_headers;
560f3c1c 4051 i < num;
b34976b6 4052 i++, internal++)
252b5132
RH		 4053 {
4054 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4055 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4056 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4057 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4058 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4059 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4060 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4061 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4062 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4063 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4064 }
4065
4066 free (shdrs);
4067
4068 return 1;
4069}
4070
9ea033b2 4071static int
2cf0635d 4072get_64bit_section_headers (FILE * file, unsigned int num)
9ea033b2 4073{
2cf0635d
NC		 4074 Elf64_External_Shdr * shdrs;
4075 Elf_Internal_Shdr * internal;
b34976b6 4076 unsigned int i;
9ea033b2 4077
3f5e193b
NC		 4078 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4079 elf_header.e_shentsize, num,
4080 _("section headers"));
a6e9f9df
AM		 4081 if (!shdrs)
4082 return 0;
9ea033b2 4083
3f5e193b
NC		 4084 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4085 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4086
4087 if (section_headers == NULL)
4088 {
4089 error (_("Out of memory\n"));
4090 return 0;
4091 }
4092
4093 for (i = 0, internal = section_headers;
560f3c1c 4094 i < num;
b34976b6 4095 i++, internal++)
9ea033b2
NC		 4096 {
4097 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4098 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4099 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4100 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4101 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4102 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4103 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4104 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4105 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4106 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4107 }
4108
4109 free (shdrs);
4110
4111 return 1;
4112}
4113
252b5132 4114static Elf_Internal_Sym *
ba5cdace
NC		 4115get_32bit_elf_symbols (FILE * file,
4116 Elf_Internal_Shdr * section,
4117 unsigned long * num_syms_return)
252b5132 4118{
ba5cdace 4119 unsigned long number = 0;
dd24e3da 4120 Elf32_External_Sym * esyms = NULL;
ba5cdace 4121 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 4122 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4123 Elf_Internal_Sym * psym;
b34976b6 4124 unsigned int j;
252b5132 4125
dd24e3da
NC		 4126 /* Run some sanity checks first. */
4127 if (section->sh_entsize == 0)
4128 {
4129 error (_("sh_entsize is zero\n"));
ba5cdace 4130 goto exit_point;
dd24e3da
NC		 4131 }
4132
4133 number = section->sh_size / section->sh_entsize;
4134
4135 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4136 {
4137 error (_("Invalid sh_entsize\n"));
ba5cdace 4138 goto exit_point;
dd24e3da
NC		 4139 }
4140
3f5e193b
NC		 4141 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4142 section->sh_size, _("symbols"));
dd24e3da 4143 if (esyms == NULL)
ba5cdace 4144 goto exit_point;
252b5132 4145
9ad5cbcf
AM		 4146 shndx = NULL;
4147 if (symtab_shndx_hdr != NULL
4148 && (symtab_shndx_hdr->sh_link
4fbb74a6 4149 == (unsigned long) (section - section_headers)))
9ad5cbcf 4150 {
3f5e193b
NC		 4151 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4152 symtab_shndx_hdr->sh_offset,
4153 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4154 _("symbol table section indicies"));
dd24e3da
NC		 4155 if (shndx == NULL)
4156 goto exit_point;
9ad5cbcf
AM		 4157 }
4158
3f5e193b 4159 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 4160
4161 if (isyms == NULL)
4162 {
4163 error (_("Out of memory\n"));
dd24e3da 4164 goto exit_point;
252b5132
RH		 4165 }
4166
dd24e3da 4167 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 4168 {
4169 psym->st_name = BYTE_GET (esyms[j].st_name);
4170 psym->st_value = BYTE_GET (esyms[j].st_value);
4171 psym->st_size = BYTE_GET (esyms[j].st_size);
4172 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 4173 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4174 psym->st_shndx
4175 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4176 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4177 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 4178 psym->st_info = BYTE_GET (esyms[j].st_info);
4179 psym->st_other = BYTE_GET (esyms[j].st_other);
4180 }
4181
dd24e3da 4182 exit_point:
ba5cdace 4183 if (shndx != NULL)
9ad5cbcf 4184 free (shndx);
ba5cdace 4185 if (esyms != NULL)
dd24e3da 4186 free (esyms);
252b5132 4187
ba5cdace
NC		 4188 if (num_syms_return != NULL)
4189 * num_syms_return = isyms == NULL ? 0 : number;
4190
252b5132
RH		 4191 return isyms;
4192}
4193
9ea033b2 4194static Elf_Internal_Sym *
ba5cdace
NC		 4195get_64bit_elf_symbols (FILE * file,
4196 Elf_Internal_Shdr * section,
4197 unsigned long * num_syms_return)
9ea033b2 4198{
ba5cdace
NC		 4199 unsigned long number = 0;
4200 Elf64_External_Sym * esyms = NULL;
4201 Elf_External_Sym_Shndx * shndx = NULL;
4202 Elf_Internal_Sym * isyms = NULL;
2cf0635d 4203 Elf_Internal_Sym * psym;
b34976b6 4204 unsigned int j;
9ea033b2 4205
dd24e3da
NC		 4206 /* Run some sanity checks first. */
4207 if (section->sh_entsize == 0)
4208 {
4209 error (_("sh_entsize is zero\n"));
ba5cdace 4210 goto exit_point;
dd24e3da
NC		 4211 }
4212
4213 number = section->sh_size / section->sh_entsize;
4214
4215 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4216 {
4217 error (_("Invalid sh_entsize\n"));
ba5cdace 4218 goto exit_point;
dd24e3da
NC		 4219 }
4220
3f5e193b
NC		 4221 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4222 section->sh_size, _("symbols"));
a6e9f9df 4223 if (!esyms)
ba5cdace 4224 goto exit_point;
9ea033b2 4225
9ad5cbcf
AM		 4226 if (symtab_shndx_hdr != NULL
4227 && (symtab_shndx_hdr->sh_link
4fbb74a6 4228 == (unsigned long) (section - section_headers)))
9ad5cbcf 4229 {
3f5e193b
NC		 4230 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4231 symtab_shndx_hdr->sh_offset,
4232 1, symtab_shndx_hdr->sh_size,
9cf03b7e 4233 _("symbol table section indicies"));
ba5cdace
NC		 4234 if (shndx == NULL)
4235 goto exit_point;
9ad5cbcf
AM		 4236 }
4237
3f5e193b 4238 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 4239
4240 if (isyms == NULL)
4241 {
4242 error (_("Out of memory\n"));
ba5cdace 4243 goto exit_point;
9ea033b2
NC		 4244 }
4245
ba5cdace 4246 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 4247 {
4248 psym->st_name = BYTE_GET (esyms[j].st_name);
4249 psym->st_info = BYTE_GET (esyms[j].st_info);
4250 psym->st_other = BYTE_GET (esyms[j].st_other);
4251 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 4252
4fbb74a6 4253 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 4254 psym->st_shndx
4255 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 4256 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4257 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 4258
66543521
AM		 4259 psym->st_value = BYTE_GET (esyms[j].st_value);
4260 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 4261 }
4262
ba5cdace
NC		 4263 exit_point:
4264 if (shndx != NULL)
9ad5cbcf 4265 free (shndx);
ba5cdace
NC		 4266 if (esyms != NULL)
4267 free (esyms);
4268
4269 if (num_syms_return != NULL)
4270 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 4271
4272 return isyms;
4273}
4274
d1133906 4275static const char *
d3ba0551 4276get_elf_section_flags (bfd_vma sh_flags)
d1133906 4277{
5477e8a0 4278 static char buff[1024];
2cf0635d 4279 char * p = buff;
8d5ff12c 4280 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 4281 int sindex;
4282 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 4283 bfd_vma os_flags = 0;
4284 bfd_vma proc_flags = 0;
4285 bfd_vma unknown_flags = 0;
148b93f2 4286 static const struct
5477e8a0 4287 {
2cf0635d 4288 const char * str;
5477e8a0
L		 4289 int len;
4290 }
4291 flags [] =
4292 {
cfcac11d
NC		 4293 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4294 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4295 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4296 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4297 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4298 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4299 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4300 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4301 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4302 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4303 /* IA-64 specific. */
4304 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4305 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4306 /* IA-64 OpenVMS specific. */
4307 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4308 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4309 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4310 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4311 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4312 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 4313 /* Generic. */
cfcac11d 4314 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 4315 /* SPARC specific. */
cfcac11d 4316 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5477e8a0
L		 4317 };
4318
4319 if (do_section_details)
4320 {
8d5ff12c
L		 4321 sprintf (buff, "[%*.*lx]: ",
4322 field_size, field_size, (unsigned long) sh_flags);
4323 p += field_size + 4;
5477e8a0 4324 }
76da6bbe 4325
d1133906
NC		 4326 while (sh_flags)
4327 {
4328 bfd_vma flag;
4329
4330 flag = sh_flags & - sh_flags;
4331 sh_flags &= ~ flag;
76da6bbe 4332
5477e8a0 4333 if (do_section_details)
d1133906 4334 {
5477e8a0
L		 4335 switch (flag)
4336 {
91d6fa6a
NC		 4337 case SHF_WRITE: sindex = 0; break;
4338 case SHF_ALLOC: sindex = 1; break;
4339 case SHF_EXECINSTR: sindex = 2; break;
4340 case SHF_MERGE: sindex = 3; break;
4341 case SHF_STRINGS: sindex = 4; break;
4342 case SHF_INFO_LINK: sindex = 5; break;
4343 case SHF_LINK_ORDER: sindex = 6; break;
4344 case SHF_OS_NONCONFORMING: sindex = 7; break;
4345 case SHF_GROUP: sindex = 8; break;
4346 case SHF_TLS: sindex = 9; break;
18ae9cc1 4347 case SHF_EXCLUDE: sindex = 18; break;
76da6bbe 4348
5477e8a0 4349 default:
91d6fa6a 4350 sindex = -1;
cfcac11d 4351 switch (elf_header.e_machine)
148b93f2 4352 {
cfcac11d 4353 case EM_IA_64:
148b93f2 4354 if (flag == SHF_IA_64_SHORT)
91d6fa6a 4355 sindex = 10;
148b93f2 4356 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 4357 sindex = 11;
148b93f2
NC		 4358#ifdef BFD64
4359 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4360 switch (flag)
4361 {
91d6fa6a
NC		 4362 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4363 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4364 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4365 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4366 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4367 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 4368 default: break;
4369 }
4370#endif
cfcac11d
NC		 4371 break;
4372
caa83f8b
NC		 4373 case EM_386:
4374 case EM_486:
4375 case EM_X86_64:
7f502d6c 4376 case EM_L1OM:
7a9068fe 4377 case EM_K1OM:
cfcac11d
NC		 4378 case EM_OLD_SPARCV9:
4379 case EM_SPARC32PLUS:
4380 case EM_SPARCV9:
4381 case EM_SPARC:
18ae9cc1 4382 if (flag == SHF_ORDERED)
91d6fa6a 4383 sindex = 19;
cfcac11d
NC		 4384 break;
4385 default:
4386 break;
148b93f2 4387 }
5477e8a0
L		 4388 }
4389
91d6fa6a 4390 if (sindex != -1)
5477e8a0 4391 {
8d5ff12c
L		 4392 if (p != buff + field_size + 4)
4393 {
4394 if (size < (10 + 2))
4395 abort ();
4396 size -= 2;
4397 *p++ = ',';
4398 *p++ = ' ';
4399 }
4400
91d6fa6a
NC		 4401 size -= flags [sindex].len;
4402 p = stpcpy (p, flags [sindex].str);
5477e8a0 4403 }
3b22753a 4404 else if (flag & SHF_MASKOS)
8d5ff12c 4405 os_flags |= flag;
d1133906 4406 else if (flag & SHF_MASKPROC)
8d5ff12c 4407 proc_flags |= flag;
d1133906 4408 else
8d5ff12c 4409 unknown_flags |= flag;
5477e8a0
L		 4410 }
4411 else
4412 {
4413 switch (flag)
4414 {
4415 case SHF_WRITE: *p = 'W'; break;
4416 case SHF_ALLOC: *p = 'A'; break;
4417 case SHF_EXECINSTR: *p = 'X'; break;
4418 case SHF_MERGE: *p = 'M'; break;
4419 case SHF_STRINGS: *p = 'S'; break;
4420 case SHF_INFO_LINK: *p = 'I'; break;
4421 case SHF_LINK_ORDER: *p = 'L'; break;
4422 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4423 case SHF_GROUP: *p = 'G'; break;
4424 case SHF_TLS: *p = 'T'; break;
18ae9cc1 4425 case SHF_EXCLUDE: *p = 'E'; break;
5477e8a0
L		 4426
4427 default:
8a9036a4 4428 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 4429 || elf_header.e_machine == EM_L1OM
4430 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 4431 && flag == SHF_X86_64_LARGE)
4432 *p = 'l';
4433 else if (flag & SHF_MASKOS)
4434 {
4435 *p = 'o';
4436 sh_flags &= ~ SHF_MASKOS;
4437 }
4438 else if (flag & SHF_MASKPROC)
4439 {
4440 *p = 'p';
4441 sh_flags &= ~ SHF_MASKPROC;
4442 }
4443 else
4444 *p = 'x';
4445 break;
4446 }
4447 p++;
d1133906
NC		 4448 }
4449 }
76da6bbe 4450
8d5ff12c
L		 4451 if (do_section_details)
4452 {
4453 if (os_flags)
4454 {
4455 size -= 5 + field_size;
4456 if (p != buff + field_size + 4)
4457 {
4458 if (size < (2 + 1))
4459 abort ();
4460 size -= 2;
4461 *p++ = ',';
4462 *p++ = ' ';
4463 }
4464 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4465 (unsigned long) os_flags);
4466 p += 5 + field_size;
4467 }
4468 if (proc_flags)
4469 {
4470 size -= 7 + field_size;
4471 if (p != buff + field_size + 4)
4472 {
4473 if (size < (2 + 1))
4474 abort ();
4475 size -= 2;
4476 *p++ = ',';
4477 *p++ = ' ';
4478 }
4479 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4480 (unsigned long) proc_flags);
4481 p += 7 + field_size;
4482 }
4483 if (unknown_flags)
4484 {
4485 size -= 10 + field_size;
4486 if (p != buff + field_size + 4)
4487 {
4488 if (size < (2 + 1))
4489 abort ();
4490 size -= 2;
4491 *p++ = ',';
4492 *p++ = ' ';
4493 }
2b692964 4494 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 4495 (unsigned long) unknown_flags);
4496 p += 10 + field_size;
4497 }
4498 }
4499
e9e44622 4500 *p = '\0';
d1133906
NC		 4501 return buff;
4502}
4503
252b5132 4504static int
2cf0635d 4505process_section_headers (FILE * file)
252b5132 4506{
2cf0635d 4507 Elf_Internal_Shdr * section;
b34976b6 4508 unsigned int i;
252b5132
RH		 4509
4510 section_headers = NULL;
4511
4512 if (elf_header.e_shnum == 0)
4513 {
82f2dbf7
NC		 4514 /* PR binutils/12467. */
4515 if (elf_header.e_shoff != 0)
4516 warn (_("possibly corrupt ELF file header - it has a non-zero"
4517 " section header offset, but no section headers\n"));
4518 else if (do_sections)
252b5132
RH		 4519 printf (_("\nThere are no sections in this file.\n"));
4520
4521 return 1;
4522 }
4523
4524 if (do_sections && !do_header)
9ea033b2 4525 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 4526 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4527
9ea033b2
NC		 4528 if (is_32bit_elf)
4529 {
560f3c1c 4530 if (! get_32bit_section_headers (file, elf_header.e_shnum))
9ea033b2
NC		 4531 return 0;
4532 }
560f3c1c 4533 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
252b5132
RH		 4534 return 0;
4535
4536 /* Read in the string table, so that we have names to display. */
0b49d371 4537 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 4538 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 4539 {
4fbb74a6 4540 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 4541
c256ffe7
JJ		 4542 if (section->sh_size != 0)
4543 {
3f5e193b
NC		 4544 string_table = (char *) get_data (NULL, file, section->sh_offset,
4545 1, section->sh_size,
4546 _("string table"));
0de14b54 4547
c256ffe7
JJ		 4548 string_table_length = string_table != NULL ? section->sh_size : 0;
4549 }
252b5132
RH		 4550 }
4551
4552 /* Scan the sections for the dynamic symbol table
e3c8793a 4553 and dynamic string table and debug sections. */
252b5132
RH		 4554 dynamic_symbols = NULL;
4555 dynamic_strings = NULL;
4556 dynamic_syminfo = NULL;
f1ef08cb 4557 symtab_shndx_hdr = NULL;
103f02d3 4558
89fac5e3
RS		 4559 eh_addr_size = is_32bit_elf ? 4 : 8;
4560 switch (elf_header.e_machine)
4561 {
4562 case EM_MIPS:
4563 case EM_MIPS_RS3_LE:
4564 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4565 FDE addresses. However, the ABI also has a semi-official ILP32
4566 variant for which the normal FDE address size rules apply.
4567
4568 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4569 section, where XX is the size of longs in bits. Unfortunately,
4570 earlier compilers provided no way of distinguishing ILP32 objects
4571 from LP64 objects, so if there's any doubt, we should assume that
4572 the official LP64 form is being used. */
4573 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4574 && find_section (".gcc_compiled_long32") == NULL)
4575 eh_addr_size = 8;
4576 break;
0f56a26a
DD		 4577
4578 case EM_H8_300:
4579 case EM_H8_300H:
4580 switch (elf_header.e_flags & EF_H8_MACH)
4581 {
4582 case E_H8_MACH_H8300:
4583 case E_H8_MACH_H8300HN:
4584 case E_H8_MACH_H8300SN:
4585 case E_H8_MACH_H8300SXN:
4586 eh_addr_size = 2;
4587 break;
4588 case E_H8_MACH_H8300H:
4589 case E_H8_MACH_H8300S:
4590 case E_H8_MACH_H8300SX:
4591 eh_addr_size = 4;
4592 break;
4593 }
f4236fe4
DD		 4594 break;
4595
ff7eeb89 4596 case EM_M32C_OLD:
f4236fe4
DD		 4597 case EM_M32C:
4598 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4599 {
4600 case EF_M32C_CPU_M16C:
4601 eh_addr_size = 2;
4602 break;
4603 }
4604 break;
89fac5e3
RS		 4605 }
4606
08d8fa11
JJ		 4607#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4608 do \
4609 { \
4610 size_t expected_entsize \
4611 = is_32bit_elf ? size32 : size64; \
4612 if (section->sh_entsize != expected_entsize) \
4613 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4614 i, (unsigned long int) section->sh_entsize, \
4615 (unsigned long int) expected_entsize); \
4616 section->sh_entsize = expected_entsize; \
4617 } \
4618 while (0)
4619#define CHECK_ENTSIZE(section, i, type) \
4620 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4621 sizeof (Elf64_External_##type))
4622
252b5132
RH		 4623 for (i = 0, section = section_headers;
4624 i < elf_header.e_shnum;
b34976b6 4625 i++, section++)
252b5132 4626 {
2cf0635d 4627 char * name = SECTION_NAME (section);
252b5132
RH		 4628
4629 if (section->sh_type == SHT_DYNSYM)
4630 {
4631 if (dynamic_symbols != NULL)
4632 {
4633 error (_("File contains multiple dynamic symbol tables\n"));
4634 continue;
4635 }
4636
08d8fa11 4637 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 4638 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 4639 }
4640 else if (section->sh_type == SHT_STRTAB
18bd398b 4641 && streq (name, ".dynstr"))
252b5132
RH		 4642 {
4643 if (dynamic_strings != NULL)
4644 {
4645 error (_("File contains multiple dynamic string tables\n"));
4646 continue;
4647 }
4648
3f5e193b
NC		 4649 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4650 1, section->sh_size,
4651 _("dynamic strings"));
59245841 4652 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 4653 }
9ad5cbcf
AM		 4654 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4655 {
4656 if (symtab_shndx_hdr != NULL)
4657 {
4658 error (_("File contains multiple symtab shndx tables\n"));
4659 continue;
4660 }
4661 symtab_shndx_hdr = section;
4662 }
08d8fa11
JJ		 4663 else if (section->sh_type == SHT_SYMTAB)
4664 CHECK_ENTSIZE (section, i, Sym);
4665 else if (section->sh_type == SHT_GROUP)
4666 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4667 else if (section->sh_type == SHT_REL)
4668 CHECK_ENTSIZE (section, i, Rel);
4669 else if (section->sh_type == SHT_RELA)
4670 CHECK_ENTSIZE (section, i, Rela);
252b5132 4671 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 4672 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 4673 || do_debug_aranges || do_debug_frames || do_debug_macinfo
a262ae96 4674 || do_debug_str || do_debug_loc || do_debug_ranges)
1b315056
CS		 4675 && (const_strneq (name, ".debug_")
4676 || const_strneq (name, ".zdebug_")))
252b5132 4677 {
1b315056
CS		 4678 if (name[1] == 'z')
4679 name += sizeof (".zdebug_") - 1;
4680 else
4681 name += sizeof (".debug_") - 1;
252b5132
RH		 4682
4683 if (do_debugging
4723351a
CC		 4684 || (do_debug_info && const_strneq (name, "info"))
4685 || (do_debug_info && const_strneq (name, "types"))
4686 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4687 || (do_debug_lines && const_strneq (name, "line"))
4688 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4689 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4690 || (do_debug_aranges && const_strneq (name, "aranges"))
4691 || (do_debug_ranges && const_strneq (name, "ranges"))
4692 || (do_debug_frames && const_strneq (name, "frame"))
4693 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4694 || (do_debug_macinfo && const_strneq (name, "macro"))
4695 || (do_debug_str && const_strneq (name, "str"))
4696 || (do_debug_loc && const_strneq (name, "loc"))
252b5132 4697 )
09c11c86 4698 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 4699 }
a262ae96 4700 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 4701 else if ((do_debugging || do_debug_info)
0112cd26 4702 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 4703 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 4704 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 4705 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 4706 else if (do_gdb_index && streq (name, ".gdb_index"))
4707 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 4708 /* Trace sections for Itanium VMS. */
4709 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4710 || do_trace_aranges)
4711 && const_strneq (name, ".trace_"))
4712 {
4713 name += sizeof (".trace_") - 1;
4714
4715 if (do_debugging
4716 || (do_trace_info && streq (name, "info"))
4717 || (do_trace_abbrevs && streq (name, "abbrev"))
4718 || (do_trace_aranges && streq (name, "aranges"))
4719 )
4720 request_dump_bynumber (i, DEBUG_DUMP);
4721 }
4722
252b5132
RH		 4723 }
4724
4725 if (! do_sections)
4726 return 1;
4727
3a1a2036
NC		 4728 if (elf_header.e_shnum > 1)
4729 printf (_("\nSection Headers:\n"));
4730 else
4731 printf (_("\nSection Header:\n"));
76da6bbe 4732
f7a99963 4733 if (is_32bit_elf)
595cf52e 4734 {
5477e8a0 4735 if (do_section_details)
595cf52e
L		 4736 {
4737 printf (_(" [Nr] Name\n"));
5477e8a0 4738 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 4739 }
4740 else
4741 printf
4742 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4743 }
d974e256 4744 else if (do_wide)
595cf52e 4745 {
5477e8a0 4746 if (do_section_details)
595cf52e
L		 4747 {
4748 printf (_(" [Nr] Name\n"));
5477e8a0 4749 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 4750 }
4751 else
4752 printf
4753 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4754 }
f7a99963
NC		 4755 else
4756 {
5477e8a0 4757 if (do_section_details)
595cf52e
L		 4758 {
4759 printf (_(" [Nr] Name\n"));
5477e8a0
L		 4760 printf (_(" Type Address Offset Link\n"));
4761 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 4762 }
4763 else
4764 {
4765 printf (_(" [Nr] Name Type Address Offset\n"));
4766 printf (_(" Size EntSize Flags Link Info Align\n"));
4767 }
f7a99963 4768 }
252b5132 4769
5477e8a0
L		 4770 if (do_section_details)
4771 printf (_(" Flags\n"));
4772
252b5132
RH		 4773 for (i = 0, section = section_headers;
4774 i < elf_header.e_shnum;
b34976b6 4775 i++, section++)
252b5132 4776 {
7bfd842d 4777 printf (" [%2u] ", i);
5477e8a0 4778 if (do_section_details)
595cf52e 4779 {
7bfd842d 4780 print_symbol (INT_MAX, SECTION_NAME (section));
ea52a088 4781 printf ("\n ");
595cf52e
L		 4782 }
4783 else
7bfd842d
NC		 4784 {
4785 print_symbol (-17, SECTION_NAME (section));
7bfd842d 4786 }
ea52a088
NC		 4787
4788 printf (do_wide ? " %-15s " : " %-15.15s ",
4789 get_section_type_name (section->sh_type));
4790
f7a99963
NC		 4791 if (is_32bit_elf)
4792 {
cfcac11d
NC		 4793 const char * link_too_big = NULL;
4794
f7a99963 4795 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 4796
f7a99963
NC		 4797 printf ( " %6.6lx %6.6lx %2.2lx",
4798 (unsigned long) section->sh_offset,
4799 (unsigned long) section->sh_size,
4800 (unsigned long) section->sh_entsize);
d1133906 4801
5477e8a0
L		 4802 if (do_section_details)
4803 fputs (" ", stdout);
4804 else
4805 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4806
cfcac11d
NC		 4807 if (section->sh_link >= elf_header.e_shnum)
4808 {
4809 link_too_big = "";
4810 /* The sh_link value is out of range. Normally this indicates
caa83f8b 4811 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 4812 switch (elf_header.e_machine)
4813 {
caa83f8b
NC		 4814 case EM_386:
4815 case EM_486:
4816 case EM_X86_64:
7f502d6c 4817 case EM_L1OM:
7a9068fe 4818 case EM_K1OM:
cfcac11d
NC		 4819 case EM_OLD_SPARCV9:
4820 case EM_SPARC32PLUS:
4821 case EM_SPARCV9:
4822 case EM_SPARC:
4823 if (section->sh_link == (SHN_BEFORE & 0xffff))
4824 link_too_big = "BEFORE";
4825 else if (section->sh_link == (SHN_AFTER & 0xffff))
4826 link_too_big = "AFTER";
4827 break;
4828 default:
4829 break;
4830 }
4831 }
4832
4833 if (do_section_details)
4834 {
4835 if (link_too_big != NULL && * link_too_big)
4836 printf ("<%s> ", link_too_big);
4837 else
4838 printf ("%2u ", section->sh_link);
4839 printf ("%3u %2lu\n", section->sh_info,
4840 (unsigned long) section->sh_addralign);
4841 }
4842 else
4843 printf ("%2u %3u %2lu\n",
4844 section->sh_link,
4845 section->sh_info,
4846 (unsigned long) section->sh_addralign);
4847
4848 if (link_too_big && ! * link_too_big)
4849 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4850 i, section->sh_link);
f7a99963 4851 }
d974e256
JJ		 4852 else if (do_wide)
4853 {
4854 print_vma (section->sh_addr, LONG_HEX);
4855
4856 if ((long) section->sh_offset == section->sh_offset)
4857 printf (" %6.6lx", (unsigned long) section->sh_offset);
4858 else
4859 {
4860 putchar (' ');
4861 print_vma (section->sh_offset, LONG_HEX);
4862 }
4863
4864 if ((unsigned long) section->sh_size == section->sh_size)
4865 printf (" %6.6lx", (unsigned long) section->sh_size);
4866 else
4867 {
4868 putchar (' ');
4869 print_vma (section->sh_size, LONG_HEX);
4870 }
4871
4872 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4873 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4874 else
4875 {
4876 putchar (' ');
4877 print_vma (section->sh_entsize, LONG_HEX);
4878 }
4879
5477e8a0
L		 4880 if (do_section_details)
4881 fputs (" ", stdout);
4882 else
4883 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 4884
72de5009 4885 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 4886
4887 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 4888 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 4889 else
4890 {
4891 print_vma (section->sh_addralign, DEC);
4892 putchar ('\n');
4893 }
4894 }
5477e8a0 4895 else if (do_section_details)
595cf52e 4896 {
5477e8a0 4897 printf (" %-15.15s ",
595cf52e 4898 get_section_type_name (section->sh_type));
595cf52e
L		 4899 print_vma (section->sh_addr, LONG_HEX);
4900 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 4901 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 4902 else
4903 {
4904 printf (" ");
4905 print_vma (section->sh_offset, LONG_HEX);
4906 }
72de5009 4907 printf (" %u\n ", section->sh_link);
595cf52e 4908 print_vma (section->sh_size, LONG_HEX);
5477e8a0 4909 putchar (' ');
595cf52e
L		 4910 print_vma (section->sh_entsize, LONG_HEX);
4911
72de5009
AM		 4912 printf (" %-16u %lu\n",
4913 section->sh_info,
595cf52e
L		 4914 (unsigned long) section->sh_addralign);
4915 }
f7a99963
NC		 4916 else
4917 {
4918 putchar (' ');
4919 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 4920 if ((long) section->sh_offset == section->sh_offset)
4921 printf (" %8.8lx", (unsigned long) section->sh_offset);
4922 else
4923 {
4924 printf (" ");
4925 print_vma (section->sh_offset, LONG_HEX);
4926 }
f7a99963
NC		 4927 printf ("\n ");
4928 print_vma (section->sh_size, LONG_HEX);
4929 printf (" ");
4930 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 4931
d1133906 4932 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 4933
72de5009
AM		 4934 printf (" %2u %3u %lu\n",
4935 section->sh_link,
4936 section->sh_info,
f7a99963
NC		 4937 (unsigned long) section->sh_addralign);
4938 }
5477e8a0
L		 4939
4940 if (do_section_details)
4941 printf (" %s\n", get_elf_section_flags (section->sh_flags));
252b5132
RH		 4942 }
4943
5477e8a0 4944 if (!do_section_details)
3dbcc61d
NC		 4945 {
4946 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 4947 || elf_header.e_machine == EM_L1OM
4948 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 4949 printf (_("Key to Flags:\n\
4950 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4951 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4952 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4953 else
4954 printf (_("Key to Flags:\n\
e3c8793a 4955 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 4956 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 4957 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3dbcc61d 4958 }
d1133906 4959
252b5132
RH		 4960 return 1;
4961}
4962
f5842774
L		 4963static const char *
4964get_group_flags (unsigned int flags)
4965{
4966 static char buff[32];
4967 switch (flags)
4968 {
220453ec
AM		 4969 case 0:
4970 return "";
4971
f5842774 4972 case GRP_COMDAT:
220453ec 4973 return "COMDAT ";
f5842774
L		 4974
4975 default:
220453ec 4976 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 4977 break;
4978 }
4979 return buff;
4980}
4981
4982static int
2cf0635d 4983process_section_groups (FILE * file)
f5842774 4984{
2cf0635d 4985 Elf_Internal_Shdr * section;
f5842774 4986 unsigned int i;
2cf0635d
NC		 4987 struct group * group;
4988 Elf_Internal_Shdr * symtab_sec;
4989 Elf_Internal_Shdr * strtab_sec;
4990 Elf_Internal_Sym * symtab;
ba5cdace 4991 unsigned long num_syms;
2cf0635d 4992 char * strtab;
c256ffe7 4993 size_t strtab_size;
d1f5c6e3
L		 4994
4995 /* Don't process section groups unless needed. */
4996 if (!do_unwind && !do_section_groups)
4997 return 1;
f5842774
L		 4998
4999 if (elf_header.e_shnum == 0)
5000 {
5001 if (do_section_groups)
82f2dbf7 5002 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 5003
5004 return 1;
5005 }
5006
5007 if (section_headers == NULL)
5008 {
5009 error (_("Section headers are not available!\n"));
fa1908fd
NC		 5010 /* PR 13622: This can happen with a corrupt ELF header. */
5011 return 0;
f5842774
L		 5012 }
5013
3f5e193b
NC		 5014 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5015 sizeof (struct group *));
e4b17d5c
L		 5016
5017 if (section_headers_groups == NULL)
5018 {
5019 error (_("Out of memory\n"));
5020 return 0;
5021 }
5022
f5842774 5023 /* Scan the sections for the group section. */
d1f5c6e3 5024 group_count = 0;
f5842774
L		 5025 for (i = 0, section = section_headers;
5026 i < elf_header.e_shnum;
5027 i++, section++)
e4b17d5c
L		 5028 if (section->sh_type == SHT_GROUP)
5029 group_count++;
5030
d1f5c6e3
L		 5031 if (group_count == 0)
5032 {
5033 if (do_section_groups)
5034 printf (_("\nThere are no section groups in this file.\n"));
5035
5036 return 1;
5037 }
5038
3f5e193b 5039 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 5040
5041 if (section_groups == NULL)
5042 {
5043 error (_("Out of memory\n"));
5044 return 0;
5045 }
5046
d1f5c6e3
L		 5047 symtab_sec = NULL;
5048 strtab_sec = NULL;
5049 symtab = NULL;
ba5cdace 5050 num_syms = 0;
d1f5c6e3 5051 strtab = NULL;
c256ffe7 5052 strtab_size = 0;
e4b17d5c
L		 5053 for (i = 0, section = section_headers, group = section_groups;
5054 i < elf_header.e_shnum;
5055 i++, section++)
f5842774
L		 5056 {
5057 if (section->sh_type == SHT_GROUP)
5058 {
2cf0635d
NC		 5059 char * name = SECTION_NAME (section);
5060 char * group_name;
5061 unsigned char * start;
5062 unsigned char * indices;
f5842774 5063 unsigned int entry, j, size;
2cf0635d
NC		 5064 Elf_Internal_Shdr * sec;
5065 Elf_Internal_Sym * sym;
f5842774
L		 5066
5067 /* Get the symbol table. */
4fbb74a6
AM		 5068 if (section->sh_link >= elf_header.e_shnum
5069 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 5070 != SHT_SYMTAB))
f5842774
L		 5071 {
5072 error (_("Bad sh_link in group section `%s'\n"), name);
5073 continue;
5074 }
d1f5c6e3
L		 5075
5076 if (symtab_sec != sec)
5077 {
5078 symtab_sec = sec;
5079 if (symtab)
5080 free (symtab);
ba5cdace 5081 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 5082 }
f5842774 5083
dd24e3da
NC		 5084 if (symtab == NULL)
5085 {
5086 error (_("Corrupt header in group section `%s'\n"), name);
5087 continue;
5088 }
5089
ba5cdace
NC		 5090 if (section->sh_info >= num_syms)
5091 {
5092 error (_("Bad sh_info in group section `%s'\n"), name);
5093 continue;
5094 }
5095
f5842774
L		 5096 sym = symtab + section->sh_info;
5097
5098 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5099 {
4fbb74a6
AM		 5100 if (sym->st_shndx == 0
5101 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 5102 {
5103 error (_("Bad sh_info in group section `%s'\n"), name);
5104 continue;
5105 }
ba2685cc 5106
4fbb74a6 5107 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 5108 strtab_sec = NULL;
5109 if (strtab)
5110 free (strtab);
f5842774 5111 strtab = NULL;
c256ffe7 5112 strtab_size = 0;
f5842774
L		 5113 }
5114 else
5115 {
5116 /* Get the string table. */
4fbb74a6 5117 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 5118 {
5119 strtab_sec = NULL;
5120 if (strtab)
5121 free (strtab);
5122 strtab = NULL;
5123 strtab_size = 0;
5124 }
5125 else if (strtab_sec
4fbb74a6 5126 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 5127 {
5128 strtab_sec = sec;
5129 if (strtab)
5130 free (strtab);
3f5e193b
NC		 5131 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5132 1, strtab_sec->sh_size,
5133 _("string table"));
c256ffe7 5134 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 5135 }
c256ffe7 5136 group_name = sym->st_name < strtab_size
2b692964 5137 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 5138 }
5139
3f5e193b
NC		 5140 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5141 1, section->sh_size,
5142 _("section data"));
59245841
NC		 5143 if (start == NULL)
5144 continue;
f5842774
L		 5145
5146 indices = start;
5147 size = (section->sh_size / section->sh_entsize) - 1;
5148 entry = byte_get (indices, 4);
5149 indices += 4;
e4b17d5c
L		 5150
5151 if (do_section_groups)
5152 {
2b692964 5153 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 5154 get_group_flags (entry), i, name, group_name, size);
ba2685cc 5155
e4b17d5c
L		 5156 printf (_(" [Index] Name\n"));
5157 }
5158
5159 group->group_index = i;
5160
f5842774
L		 5161 for (j = 0; j < size; j++)
5162 {
2cf0635d 5163 struct group_list * g;
e4b17d5c 5164
f5842774
L		 5165 entry = byte_get (indices, 4);
5166 indices += 4;
5167
4fbb74a6 5168 if (entry >= elf_header.e_shnum)
391cb864
L		 5169 {
5170 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5171 entry, i, elf_header.e_shnum - 1);
5172 continue;
5173 }
391cb864 5174
4fbb74a6 5175 if (section_headers_groups [entry] != NULL)
e4b17d5c 5176 {
d1f5c6e3
L		 5177 if (entry)
5178 {
391cb864
L		 5179 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5180 entry, i,
4fbb74a6 5181 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5182 continue;
5183 }
5184 else
5185 {
5186 /* Intel C/C++ compiler may put section 0 in a
5187 section group. We just warn it the first time
5188 and ignore it afterwards. */
5189 static int warned = 0;
5190 if (!warned)
5191 {
5192 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 5193 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 5194 warned++;
5195 }
5196 }
e4b17d5c
L		 5197 }
5198
4fbb74a6 5199 section_headers_groups [entry] = group;
e4b17d5c
L		 5200
5201 if (do_section_groups)
5202 {
4fbb74a6 5203 sec = section_headers + entry;
c256ffe7 5204 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
ba2685cc
AM		 5205 }
5206
3f5e193b 5207 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 5208 g->section_index = entry;
5209 g->next = group->root;
5210 group->root = g;
f5842774
L		 5211 }
5212
f5842774
L		 5213 if (start)
5214 free (start);
e4b17d5c
L		 5215
5216 group++;
f5842774
L		 5217 }
5218 }
5219
d1f5c6e3
L		 5220 if (symtab)
5221 free (symtab);
5222 if (strtab)
5223 free (strtab);
f5842774
L		 5224 return 1;
5225}
5226
28f997cf
TG		 5227/* Data used to display dynamic fixups. */
5228
5229struct ia64_vms_dynfixup
5230{
5231 bfd_vma needed_ident; /* Library ident number. */
5232 bfd_vma needed; /* Index in the dstrtab of the library name. */
5233 bfd_vma fixup_needed; /* Index of the library. */
5234 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5235 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5236};
5237
5238/* Data used to display dynamic relocations. */
5239
5240struct ia64_vms_dynimgrela
5241{
5242 bfd_vma img_rela_cnt; /* Number of relocations. */
5243 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5244};
5245
5246/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5247 library). */
5248
5249static void
5250dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5251 const char *strtab, unsigned int strtab_sz)
5252{
5253 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5254 long i;
5255 const char *lib_name;
5256
5257 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5258 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5259 _("dynamic section image fixups"));
5260 if (!imfs)
5261 return;
5262
5263 if (fixup->needed < strtab_sz)
5264 lib_name = strtab + fixup->needed;
5265 else
5266 {
5267 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 5268 (unsigned long) fixup->needed);
28f997cf
TG		 5269 lib_name = "???";
5270 }
5271 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5272 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5273 printf
5274 (_("Seg Offset Type SymVec DataType\n"));
5275
5276 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5277 {
5278 unsigned int type;
5279 const char *rtype;
5280
5281 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5282 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5283 type = BYTE_GET (imfs [i].type);
5284 rtype = elf_ia64_reloc_type (type);
5285 if (rtype == NULL)
5286 printf (" 0x%08x ", type);
5287 else
5288 printf (" %-32s ", rtype);
5289 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5290 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5291 }
5292
5293 free (imfs);
5294}
5295
5296/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5297
5298static void
5299dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5300{
5301 Elf64_External_VMS_IMAGE_RELA *imrs;
5302 long i;
5303
5304 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5305 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 5306 _("dynamic section image relocations"));
28f997cf
TG		 5307 if (!imrs)
5308 return;
5309
5310 printf (_("\nImage relocs\n"));
5311 printf
5312 (_("Seg Offset Type Addend Seg Sym Off\n"));
5313
5314 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5315 {
5316 unsigned int type;
5317 const char *rtype;
5318
5319 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5320 printf ("%08" BFD_VMA_FMT "x ",
5321 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5322 type = BYTE_GET (imrs [i].type);
5323 rtype = elf_ia64_reloc_type (type);
5324 if (rtype == NULL)
5325 printf ("0x%08x ", type);
5326 else
5327 printf ("%-31s ", rtype);
5328 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5329 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5330 printf ("%08" BFD_VMA_FMT "x\n",
5331 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5332 }
5333
5334 free (imrs);
5335}
5336
5337/* Display IA-64 OpenVMS dynamic relocations and fixups. */
5338
5339static int
5340process_ia64_vms_dynamic_relocs (FILE *file)
5341{
5342 struct ia64_vms_dynfixup fixup;
5343 struct ia64_vms_dynimgrela imgrela;
5344 Elf_Internal_Dyn *entry;
5345 int res = 0;
5346 bfd_vma strtab_off = 0;
5347 bfd_vma strtab_sz = 0;
5348 char *strtab = NULL;
5349
5350 memset (&fixup, 0, sizeof (fixup));
5351 memset (&imgrela, 0, sizeof (imgrela));
5352
5353 /* Note: the order of the entries is specified by the OpenVMS specs. */
5354 for (entry = dynamic_section;
5355 entry < dynamic_section + dynamic_nent;
5356 entry++)
5357 {
5358 switch (entry->d_tag)
5359 {
5360 case DT_IA_64_VMS_STRTAB_OFFSET:
5361 strtab_off = entry->d_un.d_val;
5362 break;
5363 case DT_STRSZ:
5364 strtab_sz = entry->d_un.d_val;
5365 if (strtab == NULL)
5366 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5367 1, strtab_sz, _("dynamic string section"));
5368 break;
5369
5370 case DT_IA_64_VMS_NEEDED_IDENT:
5371 fixup.needed_ident = entry->d_un.d_val;
5372 break;
5373 case DT_NEEDED:
5374 fixup.needed = entry->d_un.d_val;
5375 break;
5376 case DT_IA_64_VMS_FIXUP_NEEDED:
5377 fixup.fixup_needed = entry->d_un.d_val;
5378 break;
5379 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5380 fixup.fixup_rela_cnt = entry->d_un.d_val;
5381 break;
5382 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5383 fixup.fixup_rela_off = entry->d_un.d_val;
5384 res++;
5385 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5386 break;
5387
5388 case DT_IA_64_VMS_IMG_RELA_CNT:
5389 imgrela.img_rela_cnt = entry->d_un.d_val;
5390 break;
5391 case DT_IA_64_VMS_IMG_RELA_OFF:
5392 imgrela.img_rela_off = entry->d_un.d_val;
5393 res++;
5394 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5395 break;
5396
5397 default:
5398 break;
5399 }
5400 }
5401
5402 if (strtab != NULL)
5403 free (strtab);
5404
5405 return res;
5406}
5407
85b1c36d 5408static struct
566b0d53 5409{
2cf0635d 5410 const char * name;
566b0d53
L		 5411 int reloc;
5412 int size;
5413 int rela;
5414} dynamic_relocations [] =
5415{
5416 { "REL", DT_REL, DT_RELSZ, FALSE },
5417 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5418 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5419};
5420
252b5132 5421/* Process the reloc section. */
18bd398b 5422
252b5132 5423static int
2cf0635d 5424process_relocs (FILE * file)
252b5132 5425{
b34976b6
AM		 5426 unsigned long rel_size;
5427 unsigned long rel_offset;
252b5132
RH		 5428
5429
5430 if (!do_reloc)
5431 return 1;
5432
5433 if (do_using_dynamic)
5434 {
566b0d53 5435 int is_rela;
2cf0635d 5436 const char * name;
566b0d53
L		 5437 int has_dynamic_reloc;
5438 unsigned int i;
0de14b54 5439
566b0d53 5440 has_dynamic_reloc = 0;
252b5132 5441
566b0d53 5442 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 5443 {
566b0d53
L		 5444 is_rela = dynamic_relocations [i].rela;
5445 name = dynamic_relocations [i].name;
5446 rel_size = dynamic_info [dynamic_relocations [i].size];
5447 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 5448
566b0d53
L		 5449 has_dynamic_reloc |= rel_size;
5450
5451 if (is_rela == UNKNOWN)
aa903cfb 5452 {
566b0d53
L		 5453 if (dynamic_relocations [i].reloc == DT_JMPREL)
5454 switch (dynamic_info[DT_PLTREL])
5455 {
5456 case DT_REL:
5457 is_rela = FALSE;
5458 break;
5459 case DT_RELA:
5460 is_rela = TRUE;
5461 break;
5462 }
aa903cfb 5463 }
252b5132 5464
566b0d53
L		 5465 if (rel_size)
5466 {
5467 printf
5468 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5469 name, rel_offset, rel_size);
252b5132 5470
d93f0186
NC		 5471 dump_relocations (file,
5472 offset_from_vma (file, rel_offset, rel_size),
5473 rel_size,
566b0d53 5474 dynamic_symbols, num_dynamic_syms,
d79b3d50 5475 dynamic_strings, dynamic_strings_length, is_rela);
566b0d53 5476 }
252b5132 5477 }
566b0d53 5478
28f997cf
TG		 5479 if (is_ia64_vms ())
5480 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5481
566b0d53 5482 if (! has_dynamic_reloc)
252b5132
RH		 5483 printf (_("\nThere are no dynamic relocations in this file.\n"));
5484 }
5485 else
5486 {
2cf0635d 5487 Elf_Internal_Shdr * section;
b34976b6
AM		 5488 unsigned long i;
5489 int found = 0;
252b5132
RH		 5490
5491 for (i = 0, section = section_headers;
5492 i < elf_header.e_shnum;
b34976b6 5493 i++, section++)
252b5132
RH		 5494 {
5495 if ( section->sh_type != SHT_RELA
5496 && section->sh_type != SHT_REL)
5497 continue;
5498
5499 rel_offset = section->sh_offset;
5500 rel_size = section->sh_size;
5501
5502 if (rel_size)
5503 {
2cf0635d 5504 Elf_Internal_Shdr * strsec;
b34976b6 5505 int is_rela;
103f02d3 5506
252b5132
RH		 5507 printf (_("\nRelocation section "));
5508
5509 if (string_table == NULL)
19936277 5510 printf ("%d", section->sh_name);
252b5132 5511 else
9cf03b7e 5512 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 5513
5514 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5515 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5516
d79b3d50
NC		 5517 is_rela = section->sh_type == SHT_RELA;
5518
4fbb74a6
AM		 5519 if (section->sh_link != 0
5520 && section->sh_link < elf_header.e_shnum)
af3fc3bc 5521 {
2cf0635d
NC		 5522 Elf_Internal_Shdr * symsec;
5523 Elf_Internal_Sym * symtab;
d79b3d50 5524 unsigned long nsyms;
c256ffe7 5525 unsigned long strtablen = 0;
2cf0635d 5526 char * strtab = NULL;
57346661 5527
4fbb74a6 5528 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 5529 if (symsec->sh_type != SHT_SYMTAB
5530 && symsec->sh_type != SHT_DYNSYM)
5531 continue;
5532
ba5cdace 5533 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 5534
af3fc3bc
AM		 5535 if (symtab == NULL)
5536 continue;
252b5132 5537
4fbb74a6
AM		 5538 if (symsec->sh_link != 0
5539 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 5540 {
4fbb74a6 5541 strsec = section_headers + symsec->sh_link;
103f02d3 5542
3f5e193b
NC		 5543 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5544 1, strsec->sh_size,
5545 _("string table"));
c256ffe7
JJ		 5546 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5547 }
252b5132 5548
d79b3d50
NC		 5549 dump_relocations (file, rel_offset, rel_size,
5550 symtab, nsyms, strtab, strtablen, is_rela);
5551 if (strtab)
5552 free (strtab);
5553 free (symtab);
5554 }
5555 else
5556 dump_relocations (file, rel_offset, rel_size,
5557 NULL, 0, NULL, 0, is_rela);
252b5132
RH		 5558
5559 found = 1;
5560 }
5561 }
5562
5563 if (! found)
5564 printf (_("\nThere are no relocations in this file.\n"));
5565 }
5566
5567 return 1;
5568}
5569
57346661
AM		 5570/* Process the unwind section. */
5571
4d6ed7c8
NC		 5572#include "unwind-ia64.h"
5573
5574/* An absolute address consists of a section and an offset. If the
5575 section is NULL, the offset itself is the address, otherwise, the
5576 address equals to LOAD_ADDRESS(section) + offset. */
5577
5578struct absaddr
5579 {
5580 unsigned short section;
5581 bfd_vma offset;
5582 };
5583
1949de15
L		 5584#define ABSADDR(a) \
5585 ((a).section \
5586 ? section_headers [(a).section].sh_addr + (a).offset \
5587 : (a).offset)
5588
3f5e193b
NC		 5589struct ia64_unw_table_entry
5590 {
5591 struct absaddr start;
5592 struct absaddr end;
5593 struct absaddr info;
5594 };
5595
57346661 5596struct ia64_unw_aux_info
4d6ed7c8 5597 {
3f5e193b
NC		 5598
5599 struct ia64_unw_table_entry *table; /* Unwind table. */
b34976b6 5600 unsigned long table_len; /* Length of unwind table. */
2cf0635d 5601 unsigned char * info; /* Unwind info. */
b34976b6
AM		 5602 unsigned long info_size; /* Size of unwind info. */
5603 bfd_vma info_addr; /* starting address of unwind info. */
5604 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 5605 Elf_Internal_Sym * symtab; /* The symbol table. */
b34976b6 5606 unsigned long nsyms; /* Number of symbols. */
2cf0635d 5607 char * strtab; /* The string table. */
b34976b6 5608 unsigned long strtab_size; /* Size of string table. */
4d6ed7c8
NC		 5609 };
5610
4d6ed7c8 5611static void
2cf0635d 5612find_symbol_for_address (Elf_Internal_Sym * symtab,
57346661 5613 unsigned long nsyms,
2cf0635d 5614 const char * strtab,
57346661 5615 unsigned long strtab_size,
d3ba0551 5616 struct absaddr addr,
2cf0635d
NC		 5617 const char ** symname,
5618 bfd_vma * offset)
4d6ed7c8 5619{
d3ba0551 5620 bfd_vma dist = 0x100000;
2cf0635d
NC		 5621 Elf_Internal_Sym * sym;
5622 Elf_Internal_Sym * best = NULL;
4d6ed7c8
NC		 5623 unsigned long i;
5624
0b6ae522
DJ		 5625 REMOVE_ARCH_BITS (addr.offset);
5626
57346661 5627 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4d6ed7c8 5628 {
0b6ae522
DJ		 5629 bfd_vma value = sym->st_value;
5630
5631 REMOVE_ARCH_BITS (value);
5632
4d6ed7c8
NC		 5633 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5634 && sym->st_name != 0
5635 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 5636 && addr.offset >= value
5637 && addr.offset - value < dist)
4d6ed7c8
NC		 5638 {
5639 best = sym;
0b6ae522 5640 dist = addr.offset - value;
4d6ed7c8
NC		 5641 if (!dist)
5642 break;
5643 }
5644 }
1b31d05e 5645
4d6ed7c8
NC		 5646 if (best)
5647 {
57346661 5648 *symname = (best->st_name >= strtab_size
2b692964 5649 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 5650 *offset = dist;
5651 return;
5652 }
1b31d05e 5653
4d6ed7c8
NC		 5654 *symname = NULL;
5655 *offset = addr.offset;
5656}
5657
5658static void
2cf0635d 5659dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 5660{
2cf0635d 5661 struct ia64_unw_table_entry * tp;
4d6ed7c8 5662 int in_body;
7036c0e1 5663
4d6ed7c8
NC		 5664 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5665 {
5666 bfd_vma stamp;
5667 bfd_vma offset;
2cf0635d
NC		 5668 const unsigned char * dp;
5669 const unsigned char * head;
5670 const char * procname;
4d6ed7c8 5671
57346661
AM		 5672 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5673 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 5674
5675 fputs ("\n<", stdout);
5676
5677 if (procname)
5678 {
5679 fputs (procname, stdout);
5680
5681 if (offset)
5682 printf ("+%lx", (unsigned long) offset);
5683 }
5684
5685 fputs (">: [", stdout);
5686 print_vma (tp->start.offset, PREFIX_HEX);
5687 fputc ('-', stdout);
5688 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 5689 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 5690 (unsigned long) (tp->info.offset - aux->seg_base));
5691
1949de15 5692 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 5693 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 5694
86f55779 5695 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 5696 (unsigned) UNW_VER (stamp),
5697 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5698 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5699 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 5700 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 5701
5702 if (UNW_VER (stamp) != 1)
5703 {
2b692964 5704 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 5705 continue;
5706 }
5707
5708 in_body = 0;
89fac5e3 5709 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4d6ed7c8
NC		 5710 dp = unw_decode (dp, in_body, & in_body);
5711 }
5712}
5713
5714static int
2cf0635d
NC		 5715slurp_ia64_unwind_table (FILE * file,
5716 struct ia64_unw_aux_info * aux,
5717 Elf_Internal_Shdr * sec)
4d6ed7c8 5718{
89fac5e3 5719 unsigned long size, nrelas, i;
2cf0635d
NC		 5720 Elf_Internal_Phdr * seg;
5721 struct ia64_unw_table_entry * tep;
5722 Elf_Internal_Shdr * relsec;
5723 Elf_Internal_Rela * rela;
5724 Elf_Internal_Rela * rp;
5725 unsigned char * table;
5726 unsigned char * tp;
5727 Elf_Internal_Sym * sym;
5728 const char * relname;
4d6ed7c8 5729
4d6ed7c8
NC		 5730 /* First, find the starting address of the segment that includes
5731 this section: */
5732
5733 if (elf_header.e_phnum)
5734 {
d93f0186 5735 if (! get_program_headers (file))
4d6ed7c8 5736 return 0;
4d6ed7c8 5737
d93f0186
NC		 5738 for (seg = program_headers;
5739 seg < program_headers + elf_header.e_phnum;
5740 ++seg)
4d6ed7c8
NC		 5741 {
5742 if (seg->p_type != PT_LOAD)
5743 continue;
5744
5745 if (sec->sh_addr >= seg->p_vaddr
5746 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5747 {
5748 aux->seg_base = seg->p_vaddr;
5749 break;
5750 }
5751 }
4d6ed7c8
NC		 5752 }
5753
5754 /* Second, build the unwind table from the contents of the unwind section: */
5755 size = sec->sh_size;
3f5e193b
NC		 5756 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5757 _("unwind table"));
a6e9f9df
AM		 5758 if (!table)
5759 return 0;
4d6ed7c8 5760
3f5e193b
NC		 5761 aux->table = (struct ia64_unw_table_entry *)
5762 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
89fac5e3 5763 tep = aux->table;
c6a0c689 5764 for (tp = table; tp < table + size; ++tep)
4d6ed7c8
NC		 5765 {
5766 tep->start.section = SHN_UNDEF;
5767 tep->end.section = SHN_UNDEF;
5768 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 5769 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5770 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5771 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 5772 tep->start.offset += aux->seg_base;
5773 tep->end.offset += aux->seg_base;
5774 tep->info.offset += aux->seg_base;
5775 }
5776 free (table);
5777
41e92641 5778 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 5779 for (relsec = section_headers;
5780 relsec < section_headers + elf_header.e_shnum;
5781 ++relsec)
5782 {
5783 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 5784 || relsec->sh_info >= elf_header.e_shnum
5785 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 5786 continue;
5787
5788 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5789 & rela, & nrelas))
5790 return 0;
5791
5792 for (rp = rela; rp < rela + nrelas; ++rp)
5793 {
aca88567
NC		 5794 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5795 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 5796
0112cd26 5797 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 5798 {
e5fb9629 5799 warn (_("Skipping unexpected relocation type %s\n"), relname);
4d6ed7c8
NC		 5800 continue;
5801 }
5802
89fac5e3 5803 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 5804
89fac5e3 5805 switch (rp->r_offset/eh_addr_size % 3)
4d6ed7c8
NC		 5806 {
5807 case 0:
5808 aux->table[i].start.section = sym->st_shndx;
e466bc6e 5809 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5810 break;
5811 case 1:
5812 aux->table[i].end.section = sym->st_shndx;
e466bc6e 5813 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5814 break;
5815 case 2:
5816 aux->table[i].info.section = sym->st_shndx;
e466bc6e 5817 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 5818 break;
5819 default:
5820 break;
5821 }
5822 }
5823
5824 free (rela);
5825 }
5826
89fac5e3 5827 aux->table_len = size / (3 * eh_addr_size);
4d6ed7c8
NC		 5828 return 1;
5829}
5830
1b31d05e 5831static void
2cf0635d 5832ia64_process_unwind (FILE * file)
4d6ed7c8 5833{
2cf0635d
NC		 5834 Elf_Internal_Shdr * sec;
5835 Elf_Internal_Shdr * unwsec = NULL;
5836 Elf_Internal_Shdr * strsec;
89fac5e3 5837 unsigned long i, unwcount = 0, unwstart = 0;
57346661 5838 struct ia64_unw_aux_info aux;
f1467e33 5839
4d6ed7c8
NC		 5840 memset (& aux, 0, sizeof (aux));
5841
4d6ed7c8
NC		 5842 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5843 {
c256ffe7 5844 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 5845 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 5846 {
ba5cdace 5847 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 5848
4fbb74a6 5849 strsec = section_headers + sec->sh_link;
59245841 5850 assert (aux.strtab == NULL);
3f5e193b
NC		 5851 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5852 1, strsec->sh_size,
5853 _("string table"));
c256ffe7 5854 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 5855 }
5856 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 5857 unwcount++;
5858 }
5859
5860 if (!unwcount)
5861 printf (_("\nThere are no unwind sections in this file.\n"));
5862
5863 while (unwcount-- > 0)
5864 {
2cf0635d 5865 char * suffix;
579f31ac
JJ		 5866 size_t len, len2;
5867
5868 for (i = unwstart, sec = section_headers + unwstart;
5869 i < elf_header.e_shnum; ++i, ++sec)
5870 if (sec->sh_type == SHT_IA_64_UNWIND)
5871 {
5872 unwsec = sec;
5873 break;
5874 }
5875
5876 unwstart = i + 1;
5877 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5878
e4b17d5c
L		 5879 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5880 {
5881 /* We need to find which section group it is in. */
2cf0635d 5882 struct group_list * g = section_headers_groups [i]->root;
e4b17d5c
L		 5883
5884 for (; g != NULL; g = g->next)
5885 {
4fbb74a6 5886 sec = section_headers + g->section_index;
18bd398b
NC		 5887
5888 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
57346661 5889 break;
e4b17d5c
L		 5890 }
5891
5892 if (g == NULL)
5893 i = elf_header.e_shnum;
5894 }
18bd398b 5895 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 5896 {
18bd398b 5897 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 5898 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5899 suffix = SECTION_NAME (unwsec) + len;
5900 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5901 ++i, ++sec)
18bd398b
NC		 5902 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5903 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5904 break;
5905 }
5906 else
5907 {
5908 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 5909 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 5910 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5911 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5912 suffix = "";
18bd398b 5913 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 5914 suffix = SECTION_NAME (unwsec) + len;
5915 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5916 ++i, ++sec)
18bd398b
NC		 5917 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5918 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 5919 break;
5920 }
5921
5922 if (i == elf_header.e_shnum)
5923 {
5924 printf (_("\nCould not find unwind info section for "));
5925
5926 if (string_table == NULL)
5927 printf ("%d", unwsec->sh_name);
5928 else
3a1a2036 5929 printf (_("'%s'"), SECTION_NAME (unwsec));
579f31ac
JJ		 5930 }
5931 else
4d6ed7c8 5932 {
4d6ed7c8 5933 aux.info_addr = sec->sh_addr;
3f5e193b 5934 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
59245841 5935 sec->sh_size,
3f5e193b 5936 _("unwind info"));
59245841 5937 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 5938
579f31ac 5939 printf (_("\nUnwind section "));
4d6ed7c8 5940
579f31ac
JJ		 5941 if (string_table == NULL)
5942 printf ("%d", unwsec->sh_name);
5943 else
3a1a2036 5944 printf (_("'%s'"), SECTION_NAME (unwsec));
4d6ed7c8 5945
579f31ac 5946 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 5947 (unsigned long) unwsec->sh_offset,
89fac5e3 5948 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 5949
579f31ac 5950 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4d6ed7c8 5951
579f31ac
JJ		 5952 if (aux.table_len > 0)
5953 dump_ia64_unwind (& aux);
5954
5955 if (aux.table)
5956 free ((char *) aux.table);
5957 if (aux.info)
5958 free ((char *) aux.info);
5959 aux.table = NULL;
5960 aux.info = NULL;
5961 }
4d6ed7c8 5962 }
4d6ed7c8 5963
4d6ed7c8
NC		 5964 if (aux.symtab)
5965 free (aux.symtab);
5966 if (aux.strtab)
5967 free ((char *) aux.strtab);
4d6ed7c8
NC		 5968}
5969
3f5e193b
NC		 5970struct hppa_unw_table_entry
5971 {
5972 struct absaddr start;
5973 struct absaddr end;
5974 unsigned int Cannot_unwind:1; /* 0 */
5975 unsigned int Millicode:1; /* 1 */
5976 unsigned int Millicode_save_sr0:1; /* 2 */
5977 unsigned int Region_description:2; /* 3..4 */
5978 unsigned int reserved1:1; /* 5 */
5979 unsigned int Entry_SR:1; /* 6 */
5980 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5981 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5982 unsigned int Args_stored:1; /* 16 */
5983 unsigned int Variable_Frame:1; /* 17 */
5984 unsigned int Separate_Package_Body:1; /* 18 */
5985 unsigned int Frame_Extension_Millicode:1; /* 19 */
5986 unsigned int Stack_Overflow_Check:1; /* 20 */
5987 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5988 unsigned int Ada_Region:1; /* 22 */
5989 unsigned int cxx_info:1; /* 23 */
5990 unsigned int cxx_try_catch:1; /* 24 */
5991 unsigned int sched_entry_seq:1; /* 25 */
5992 unsigned int reserved2:1; /* 26 */
5993 unsigned int Save_SP:1; /* 27 */
5994 unsigned int Save_RP:1; /* 28 */
5995 unsigned int Save_MRP_in_frame:1; /* 29 */
5996 unsigned int extn_ptr_defined:1; /* 30 */
5997 unsigned int Cleanup_defined:1; /* 31 */
5998
5999 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6000 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6001 unsigned int Large_frame:1; /* 2 */
6002 unsigned int Pseudo_SP_Set:1; /* 3 */
6003 unsigned int reserved4:1; /* 4 */
6004 unsigned int Total_frame_size:27; /* 5..31 */
6005 };
6006
57346661
AM		 6007struct hppa_unw_aux_info
6008 {
3f5e193b 6009 struct hppa_unw_table_entry *table; /* Unwind table. */
57346661
AM		 6010 unsigned long table_len; /* Length of unwind table. */
6011 bfd_vma seg_base; /* Starting address of segment. */
2cf0635d 6012 Elf_Internal_Sym * symtab; /* The symbol table. */
57346661 6013 unsigned long nsyms; /* Number of symbols. */
2cf0635d 6014 char * strtab; /* The string table. */
57346661
AM		 6015 unsigned long strtab_size; /* Size of string table. */
6016 };
6017
6018static void
2cf0635d 6019dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 6020{
2cf0635d 6021 struct hppa_unw_table_entry * tp;
57346661 6022
57346661
AM		 6023 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6024 {
6025 bfd_vma offset;
2cf0635d 6026 const char * procname;
57346661
AM		 6027
6028 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6029 aux->strtab_size, tp->start, &procname,
6030 &offset);
6031
6032 fputs ("\n<", stdout);
6033
6034 if (procname)
6035 {
6036 fputs (procname, stdout);
6037
6038 if (offset)
6039 printf ("+%lx", (unsigned long) offset);
6040 }
6041
6042 fputs (">: [", stdout);
6043 print_vma (tp->start.offset, PREFIX_HEX);
6044 fputc ('-', stdout);
6045 print_vma (tp->end.offset, PREFIX_HEX);
6046 printf ("]\n\t");
6047
18bd398b
NC		 6048#define PF(_m) if (tp->_m) printf (#_m " ");
6049#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 6050 PF(Cannot_unwind);
6051 PF(Millicode);
6052 PF(Millicode_save_sr0);
18bd398b 6053 /* PV(Region_description); */
57346661
AM		 6054 PF(Entry_SR);
6055 PV(Entry_FR);
6056 PV(Entry_GR);
6057 PF(Args_stored);
6058 PF(Variable_Frame);
6059 PF(Separate_Package_Body);
6060 PF(Frame_Extension_Millicode);
6061 PF(Stack_Overflow_Check);
6062 PF(Two_Instruction_SP_Increment);
6063 PF(Ada_Region);
6064 PF(cxx_info);
6065 PF(cxx_try_catch);
6066 PF(sched_entry_seq);
6067 PF(Save_SP);
6068 PF(Save_RP);
6069 PF(Save_MRP_in_frame);
6070 PF(extn_ptr_defined);
6071 PF(Cleanup_defined);
6072 PF(MPE_XL_interrupt_marker);
6073 PF(HP_UX_interrupt_marker);
6074 PF(Large_frame);
6075 PF(Pseudo_SP_Set);
6076 PV(Total_frame_size);
6077#undef PF
6078#undef PV
6079 }
6080
18bd398b 6081 printf ("\n");
57346661
AM		 6082}
6083
6084static int
2cf0635d
NC		 6085slurp_hppa_unwind_table (FILE * file,
6086 struct hppa_unw_aux_info * aux,
6087 Elf_Internal_Shdr * sec)
57346661 6088{
1c0751b2 6089 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 6090 Elf_Internal_Phdr * seg;
6091 struct hppa_unw_table_entry * tep;
6092 Elf_Internal_Shdr * relsec;
6093 Elf_Internal_Rela * rela;
6094 Elf_Internal_Rela * rp;
6095 unsigned char * table;
6096 unsigned char * tp;
6097 Elf_Internal_Sym * sym;
6098 const char * relname;
57346661 6099
57346661
AM		 6100 /* First, find the starting address of the segment that includes
6101 this section. */
6102
6103 if (elf_header.e_phnum)
6104 {
6105 if (! get_program_headers (file))
6106 return 0;
6107
6108 for (seg = program_headers;
6109 seg < program_headers + elf_header.e_phnum;
6110 ++seg)
6111 {
6112 if (seg->p_type != PT_LOAD)
6113 continue;
6114
6115 if (sec->sh_addr >= seg->p_vaddr
6116 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6117 {
6118 aux->seg_base = seg->p_vaddr;
6119 break;
6120 }
6121 }
6122 }
6123
6124 /* Second, build the unwind table from the contents of the unwind
6125 section. */
6126 size = sec->sh_size;
3f5e193b
NC		 6127 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6128 _("unwind table"));
57346661
AM		 6129 if (!table)
6130 return 0;
6131
1c0751b2
DA		 6132 unw_ent_size = 16;
6133 nentries = size / unw_ent_size;
6134 size = unw_ent_size * nentries;
57346661 6135
3f5e193b
NC		 6136 tep = aux->table = (struct hppa_unw_table_entry *)
6137 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 6138
1c0751b2 6139 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 6140 {
6141 unsigned int tmp1, tmp2;
6142
6143 tep->start.section = SHN_UNDEF;
6144 tep->end.section = SHN_UNDEF;
6145
1c0751b2
DA		 6146 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6147 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6148 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6149 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6150
6151 tep->start.offset += aux->seg_base;
6152 tep->end.offset += aux->seg_base;
57346661
AM		 6153
6154 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6155 tep->Millicode = (tmp1 >> 30) & 0x1;
6156 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6157 tep->Region_description = (tmp1 >> 27) & 0x3;
6158 tep->reserved1 = (tmp1 >> 26) & 0x1;
6159 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6160 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6161 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6162 tep->Args_stored = (tmp1 >> 15) & 0x1;
6163 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6164 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6165 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6166 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6167 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6168 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6169 tep->cxx_info = (tmp1 >> 8) & 0x1;
6170 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6171 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6172 tep->reserved2 = (tmp1 >> 5) & 0x1;
6173 tep->Save_SP = (tmp1 >> 4) & 0x1;
6174 tep->Save_RP = (tmp1 >> 3) & 0x1;
6175 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6176 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6177 tep->Cleanup_defined = tmp1 & 0x1;
6178
6179 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6180 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6181 tep->Large_frame = (tmp2 >> 29) & 0x1;
6182 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6183 tep->reserved4 = (tmp2 >> 27) & 0x1;
6184 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 6185 }
6186 free (table);
6187
6188 /* Third, apply any relocations to the unwind table. */
57346661
AM		 6189 for (relsec = section_headers;
6190 relsec < section_headers + elf_header.e_shnum;
6191 ++relsec)
6192 {
6193 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6194 || relsec->sh_info >= elf_header.e_shnum
6195 || section_headers + relsec->sh_info != sec)
57346661
AM		 6196 continue;
6197
6198 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6199 & rela, & nrelas))
6200 return 0;
6201
6202 for (rp = rela; rp < rela + nrelas; ++rp)
6203 {
aca88567
NC		 6204 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6205 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 6206
6207 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 6208 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 6209 {
6210 warn (_("Skipping unexpected relocation type %s\n"), relname);
6211 continue;
6212 }
6213
6214 i = rp->r_offset / unw_ent_size;
6215
89fac5e3 6216 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 6217 {
6218 case 0:
6219 aux->table[i].start.section = sym->st_shndx;
1e456d54 6220 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 6221 break;
6222 case 1:
6223 aux->table[i].end.section = sym->st_shndx;
1e456d54 6224 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 6225 break;
6226 default:
6227 break;
6228 }
6229 }
6230
6231 free (rela);
6232 }
6233
1c0751b2 6234 aux->table_len = nentries;
57346661
AM		 6235
6236 return 1;
6237}
6238
1b31d05e 6239static void
2cf0635d 6240hppa_process_unwind (FILE * file)
57346661 6241{
57346661 6242 struct hppa_unw_aux_info aux;
2cf0635d
NC		 6243 Elf_Internal_Shdr * unwsec = NULL;
6244 Elf_Internal_Shdr * strsec;
6245 Elf_Internal_Shdr * sec;
18bd398b 6246 unsigned long i;
57346661 6247
c256ffe7 6248 if (string_table == NULL)
1b31d05e
NC		 6249 return;
6250
6251 memset (& aux, 0, sizeof (aux));
57346661
AM		 6252
6253 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6254 {
c256ffe7 6255 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6256 && sec->sh_link < elf_header.e_shnum)
57346661 6257 {
ba5cdace 6258 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 6259
4fbb74a6 6260 strsec = section_headers + sec->sh_link;
59245841 6261 assert (aux.strtab == NULL);
3f5e193b
NC		 6262 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6263 1, strsec->sh_size,
6264 _("string table"));
c256ffe7 6265 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 6266 }
18bd398b 6267 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 6268 unwsec = sec;
6269 }
6270
6271 if (!unwsec)
6272 printf (_("\nThere are no unwind sections in this file.\n"));
6273
6274 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6275 {
18bd398b 6276 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 6277 {
57346661
AM		 6278 printf (_("\nUnwind section "));
6279 printf (_("'%s'"), SECTION_NAME (sec));
6280
6281 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6282 (unsigned long) sec->sh_offset,
89fac5e3 6283 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 6284
6285 slurp_hppa_unwind_table (file, &aux, sec);
6286 if (aux.table_len > 0)
6287 dump_hppa_unwind (&aux);
6288
6289 if (aux.table)
6290 free ((char *) aux.table);
6291 aux.table = NULL;
6292 }
6293 }
6294
6295 if (aux.symtab)
6296 free (aux.symtab);
6297 if (aux.strtab)
6298 free ((char *) aux.strtab);
57346661
AM		 6299}
6300
0b6ae522
DJ		 6301struct arm_section
6302{
a734115a
NC		 6303 unsigned char * data; /* The unwind data. */
6304 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6305 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6306 unsigned long nrelas; /* The number of relocations. */
6307 unsigned int rel_type; /* REL or RELA ? */
6308 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 6309};
6310
6311struct arm_unw_aux_info
6312{
a734115a
NC		 6313 FILE * file; /* The file containing the unwind sections. */
6314 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6315 unsigned long nsyms; /* Number of symbols. */
6316 char * strtab; /* The file's string table. */
6317 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 6318};
6319
6320static const char *
6321arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6322 bfd_vma fn, struct absaddr addr)
6323{
6324 const char *procname;
6325 bfd_vma sym_offset;
6326
6327 if (addr.section == SHN_UNDEF)
6328 addr.offset = fn;
6329
6330 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6331 aux->strtab_size, addr, &procname,
6332 &sym_offset);
6333
6334 print_vma (fn, PREFIX_HEX);
6335
6336 if (procname)
6337 {
6338 fputs (" <", stdout);
6339 fputs (procname, stdout);
6340
6341 if (sym_offset)
6342 printf ("+0x%lx", (unsigned long) sym_offset);
6343 fputc ('>', stdout);
6344 }
6345
6346 return procname;
6347}
6348
6349static void
6350arm_free_section (struct arm_section *arm_sec)
6351{
6352 if (arm_sec->data != NULL)
6353 free (arm_sec->data);
6354
6355 if (arm_sec->rela != NULL)
6356 free (arm_sec->rela);
6357}
6358
a734115a
NC		 6359/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6360 cached section and install SEC instead.
6361 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6362 and return its valued in * WORDP, relocating if necessary.
1b31d05e 6363 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 6364 relocation's offset in ADDR.
1b31d05e
NC		 6365 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6366 into the string table of the symbol associated with the reloc. If no
6367 reloc was applied store -1 there.
6368 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 6369
6370static bfd_boolean
1b31d05e
NC		 6371get_unwind_section_word (struct arm_unw_aux_info * aux,
6372 struct arm_section * arm_sec,
6373 Elf_Internal_Shdr * sec,
6374 bfd_vma word_offset,
6375 unsigned int * wordp,
6376 struct absaddr * addr,
6377 bfd_vma * sym_name)
0b6ae522
DJ		 6378{
6379 Elf_Internal_Rela *rp;
6380 Elf_Internal_Sym *sym;
6381 const char * relname;
6382 unsigned int word;
6383 bfd_boolean wrapped;
6384
6385 addr->section = SHN_UNDEF;
6386 addr->offset = 0;
6387
1b31d05e
NC		 6388 if (sym_name != NULL)
6389 *sym_name = (bfd_vma) -1;
6390
a734115a 6391 /* If necessary, update the section cache. */
0b6ae522
DJ		 6392 if (sec != arm_sec->sec)
6393 {
6394 Elf_Internal_Shdr *relsec;
6395
6396 arm_free_section (arm_sec);
6397
6398 arm_sec->sec = sec;
6399 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6400 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 6401 arm_sec->rela = NULL;
6402 arm_sec->nrelas = 0;
6403
6404 for (relsec = section_headers;
6405 relsec < section_headers + elf_header.e_shnum;
6406 ++relsec)
6407 {
6408 if (relsec->sh_info >= elf_header.e_shnum
6409 || section_headers + relsec->sh_info != sec)
6410 continue;
6411
a734115a 6412 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 6413 if (relsec->sh_type == SHT_REL)
6414 {
6415 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6416 relsec->sh_size,
6417 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6418 return FALSE;
0b6ae522
DJ		 6419 break;
6420 }
6421 else if (relsec->sh_type == SHT_RELA)
6422 {
6423 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6424 relsec->sh_size,
6425 & arm_sec->rela, & arm_sec->nrelas))
a734115a 6426 return FALSE;
0b6ae522
DJ		 6427 break;
6428 }
a734115a
NC		 6429 else
6430 warn (_("unexpected relocation type (%d) for section %d"),
6431 relsec->sh_type, relsec->sh_info);
0b6ae522
DJ		 6432 }
6433
6434 arm_sec->next_rela = arm_sec->rela;
6435 }
6436
a734115a 6437 /* If there is no unwind data we can do nothing. */
0b6ae522 6438 if (arm_sec->data == NULL)
a734115a 6439 return FALSE;
0b6ae522 6440
a734115a 6441 /* Get the word at the required offset. */
0b6ae522
DJ		 6442 word = byte_get (arm_sec->data + word_offset, 4);
6443
a734115a 6444 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 6445 wrapped = FALSE;
6446 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6447 {
6448 bfd_vma prelval, offset;
6449
6450 if (rp->r_offset > word_offset && !wrapped)
6451 {
6452 rp = arm_sec->rela;
6453 wrapped = TRUE;
6454 }
6455 if (rp->r_offset > word_offset)
6456 break;
6457
6458 if (rp->r_offset & 3)
6459 {
6460 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6461 (unsigned long) rp->r_offset);
6462 continue;
6463 }
6464
6465 if (rp->r_offset < word_offset)
6466 continue;
6467
0b6ae522
DJ		 6468 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6469
6470 if (arm_sec->rel_type == SHT_REL)
6471 {
6472 offset = word & 0x7fffffff;
6473 if (offset & 0x40000000)
6474 offset |= ~ (bfd_vma) 0x7fffffff;
6475 }
a734115a 6476 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 6477 offset = rp->r_addend;
a734115a
NC		 6478 else
6479 abort ();
0b6ae522
DJ		 6480
6481 offset += sym->st_value;
6482 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6483
a734115a
NC		 6484 /* Check that we are processing the expected reloc type. */
6485 if (elf_header.e_machine == EM_ARM)
6486 {
6487 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6488
6489 if (streq (relname, "R_ARM_NONE"))
6490 continue;
6491
6492 if (! streq (relname, "R_ARM_PREL31"))
6493 {
6494 warn (_("Skipping unexpected relocation type %s\n"), relname);
6495 continue;
6496 }
6497 }
6498 else if (elf_header.e_machine == EM_TI_C6000)
6499 {
6500 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6501
6502 if (streq (relname, "R_C6000_NONE"))
6503 continue;
6504
6505 if (! streq (relname, "R_C6000_PREL31"))
6506 {
6507 warn (_("Skipping unexpected relocation type %s\n"), relname);
6508 continue;
6509 }
6510
6511 prelval >>= 1;
6512 }
6513 else
6514 /* This function currently only supports ARM and TI unwinders. */
6515 abort ();
fa197c1c 6516
0b6ae522
DJ		 6517 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6518 addr->section = sym->st_shndx;
6519 addr->offset = offset;
1b31d05e
NC		 6520 if (sym_name)
6521 * sym_name = sym->st_name;
0b6ae522
DJ		 6522 break;
6523 }
6524
6525 *wordp = word;
6526 arm_sec->next_rela = rp;
6527
a734115a 6528 return TRUE;
0b6ae522
DJ		 6529}
6530
a734115a
NC		 6531static const char *tic6x_unwind_regnames[16] =
6532{
6533 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6534 "A14", "A13", "A12", "A11", "A10",
6535 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6536};
fa197c1c 6537
0b6ae522 6538static void
fa197c1c 6539decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 6540{
fa197c1c
PB		 6541 int i;
6542
6543 for (i = 12; mask; mask >>= 1, i--)
6544 {
6545 if (mask & 1)
6546 {
6547 fputs (tic6x_unwind_regnames[i], stdout);
6548 if (mask > 1)
6549 fputs (", ", stdout);
6550 }
6551 }
6552}
0b6ae522
DJ		 6553
6554#define ADVANCE \
6555 if (remaining == 0 && more_words) \
6556 { \
6557 data_offset += 4; \
1b31d05e
NC		 6558 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6559 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 6560 return; \
6561 remaining = 4; \
6562 more_words--; \
6563 } \
6564
6565#define GET_OP(OP) \
6566 ADVANCE; \
6567 if (remaining) \
6568 { \
6569 remaining--; \
6570 (OP) = word >> 24; \
6571 word <<= 8; \
6572 } \
6573 else \
6574 { \
2b692964 6575 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 6576 return; \
6577 } \
cc5914eb 6578 printf ("0x%02x ", OP)
0b6ae522 6579
fa197c1c
PB		 6580static void
6581decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6582 unsigned int word, unsigned int remaining,
6583 unsigned int more_words,
6584 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6585 struct arm_section *data_arm_sec)
6586{
6587 struct absaddr addr;
0b6ae522
DJ		 6588
6589 /* Decode the unwinding instructions. */
6590 while (1)
6591 {
6592 unsigned int op, op2;
6593
6594 ADVANCE;
6595 if (remaining == 0)
6596 break;
6597 remaining--;
6598 op = word >> 24;
6599 word <<= 8;
6600
cc5914eb 6601 printf (" 0x%02x ", op);
0b6ae522
DJ		 6602
6603 if ((op & 0xc0) == 0x00)
6604 {
6605 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6606
cc5914eb 6607 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 6608 }
6609 else if ((op & 0xc0) == 0x40)
6610 {
6611 int offset = ((op & 0x3f) << 2) + 4;
61865e30 6612
cc5914eb 6613 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 6614 }
6615 else if ((op & 0xf0) == 0x80)
6616 {
6617 GET_OP (op2);
6618 if (op == 0x80 && op2 == 0)
6619 printf (_("Refuse to unwind"));
6620 else
6621 {
6622 unsigned int mask = ((op & 0x0f) << 8) | op2;
6623 int first = 1;
6624 int i;
2b692964 6625
0b6ae522
DJ		 6626 printf ("pop {");
6627 for (i = 0; i < 12; i++)
6628 if (mask & (1 << i))
6629 {
6630 if (first)
6631 first = 0;
6632 else
6633 printf (", ");
6634 printf ("r%d", 4 + i);
6635 }
6636 printf ("}");
6637 }
6638 }
6639 else if ((op & 0xf0) == 0x90)
6640 {
6641 if (op == 0x9d || op == 0x9f)
6642 printf (_(" [Reserved]"));
6643 else
cc5914eb 6644 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 6645 }
6646 else if ((op & 0xf0) == 0xa0)
6647 {
6648 int end = 4 + (op & 0x07);
6649 int first = 1;
6650 int i;
61865e30 6651
0b6ae522
DJ		 6652 printf (" pop {");
6653 for (i = 4; i <= end; i++)
6654 {
6655 if (first)
6656 first = 0;
6657 else
6658 printf (", ");
6659 printf ("r%d", i);
6660 }
6661 if (op & 0x08)
6662 {
1b31d05e 6663 if (!first)
0b6ae522
DJ		 6664 printf (", ");
6665 printf ("r14");
6666 }
6667 printf ("}");
6668 }
6669 else if (op == 0xb0)
6670 printf (_(" finish"));
6671 else if (op == 0xb1)
6672 {
6673 GET_OP (op2);
6674 if (op2 == 0 || (op2 & 0xf0) != 0)
6675 printf (_("[Spare]"));
6676 else
6677 {
6678 unsigned int mask = op2 & 0x0f;
6679 int first = 1;
6680 int i;
61865e30 6681
0b6ae522
DJ		 6682 printf ("pop {");
6683 for (i = 0; i < 12; i++)
6684 if (mask & (1 << i))
6685 {
6686 if (first)
6687 first = 0;
6688 else
6689 printf (", ");
6690 printf ("r%d", i);
6691 }
6692 printf ("}");
6693 }
6694 }
6695 else if (op == 0xb2)
6696 {
b115cf96 6697 unsigned char buf[9];
0b6ae522
DJ		 6698 unsigned int i, len;
6699 unsigned long offset;
61865e30 6700
b115cf96 6701 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 6702 {
6703 GET_OP (buf[i]);
6704 if ((buf[i] & 0x80) == 0)
6705 break;
6706 }
6707 assert (i < sizeof (buf));
6708 offset = read_uleb128 (buf, &len);
6709 assert (len == i + 1);
6710 offset = offset * 4 + 0x204;
cc5914eb 6711 printf ("vsp = vsp + %ld", offset);
0b6ae522 6712 }
61865e30 6713 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 6714 {
61865e30
NC		 6715 unsigned int first, last;
6716
6717 GET_OP (op2);
6718 first = op2 >> 4;
6719 last = op2 & 0x0f;
6720 if (op == 0xc8)
6721 first = first + 16;
6722 printf ("pop {D%d", first);
6723 if (last)
6724 printf ("-D%d", first + last);
6725 printf ("}");
6726 }
6727 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6728 {
6729 unsigned int count = op & 0x07;
6730
6731 printf ("pop {D8");
6732 if (count)
6733 printf ("-D%d", 8 + count);
6734 printf ("}");
6735 }
6736 else if (op >= 0xc0 && op <= 0xc5)
6737 {
6738 unsigned int count = op & 0x07;
6739
6740 printf (" pop {wR10");
6741 if (count)
6742 printf ("-wR%d", 10 + count);
6743 printf ("}");
6744 }
6745 else if (op == 0xc6)
6746 {
6747 unsigned int first, last;
6748
6749 GET_OP (op2);
6750 first = op2 >> 4;
6751 last = op2 & 0x0f;
6752 printf ("pop {wR%d", first);
6753 if (last)
6754 printf ("-wR%d", first + last);
6755 printf ("}");
6756 }
6757 else if (op == 0xc7)
6758 {
6759 GET_OP (op2);
6760 if (op2 == 0 || (op2 & 0xf0) != 0)
6761 printf (_("[Spare]"));
0b6ae522
DJ		 6762 else
6763 {
61865e30
NC		 6764 unsigned int mask = op2 & 0x0f;
6765 int first = 1;
6766 int i;
6767
6768 printf ("pop {");
6769 for (i = 0; i < 4; i++)
6770 if (mask & (1 << i))
6771 {
6772 if (first)
6773 first = 0;
6774 else
6775 printf (", ");
6776 printf ("wCGR%d", i);
6777 }
6778 printf ("}");
0b6ae522
DJ		 6779 }
6780 }
61865e30
NC		 6781 else
6782 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 6783 printf ("\n");
6784 }
fa197c1c
PB		 6785}
6786
6787static void
6788decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6789 unsigned int word, unsigned int remaining,
6790 unsigned int more_words,
6791 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6792 struct arm_section *data_arm_sec)
6793{
6794 struct absaddr addr;
6795
6796 /* Decode the unwinding instructions. */
6797 while (1)
6798 {
6799 unsigned int op, op2;
6800
6801 ADVANCE;
6802 if (remaining == 0)
6803 break;
6804 remaining--;
6805 op = word >> 24;
6806 word <<= 8;
6807
9cf03b7e 6808 printf (" 0x%02x ", op);
fa197c1c
PB		 6809
6810 if ((op & 0xc0) == 0x00)
6811 {
6812 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 6813 printf (" sp = sp + %d", offset);
fa197c1c
PB		 6814 }
6815 else if ((op & 0xc0) == 0x80)
6816 {
6817 GET_OP (op2);
6818 if (op == 0x80 && op2 == 0)
6819 printf (_("Refuse to unwind"));
6820 else
6821 {
6822 unsigned int mask = ((op & 0x1f) << 8) | op2;
6823 if (op & 0x20)
6824 printf ("pop compact {");
6825 else
6826 printf ("pop {");
6827
6828 decode_tic6x_unwind_regmask (mask);
6829 printf("}");
6830 }
6831 }
6832 else if ((op & 0xf0) == 0xc0)
6833 {
6834 unsigned int reg;
6835 unsigned int nregs;
6836 unsigned int i;
6837 const char *name;
a734115a
NC		 6838 struct
6839 {
fa197c1c
PB		 6840 unsigned int offset;
6841 unsigned int reg;
6842 } regpos[16];
6843
6844 /* Scan entire instruction first so that GET_OP output is not
6845 interleaved with disassembly. */
6846 nregs = 0;
6847 for (i = 0; nregs < (op & 0xf); i++)
6848 {
6849 GET_OP (op2);
6850 reg = op2 >> 4;
6851 if (reg != 0xf)
6852 {
6853 regpos[nregs].offset = i * 2;
6854 regpos[nregs].reg = reg;
6855 nregs++;
6856 }
6857
6858 reg = op2 & 0xf;
6859 if (reg != 0xf)
6860 {
6861 regpos[nregs].offset = i * 2 + 1;
6862 regpos[nregs].reg = reg;
6863 nregs++;
6864 }
6865 }
6866
6867 printf (_("pop frame {"));
6868 reg = nregs - 1;
6869 for (i = i * 2; i > 0; i--)
6870 {
6871 if (regpos[reg].offset == i - 1)
6872 {
6873 name = tic6x_unwind_regnames[regpos[reg].reg];
6874 if (reg > 0)
6875 reg--;
6876 }
6877 else
6878 name = _("[pad]");
6879
6880 fputs (name, stdout);
6881 if (i > 1)
6882 printf (", ");
6883 }
6884
6885 printf ("}");
6886 }
6887 else if (op == 0xd0)
6888 printf (" MOV FP, SP");
6889 else if (op == 0xd1)
6890 printf (" __c6xabi_pop_rts");
6891 else if (op == 0xd2)
6892 {
6893 unsigned char buf[9];
6894 unsigned int i, len;
6895 unsigned long offset;
a734115a 6896
fa197c1c
PB		 6897 for (i = 0; i < sizeof (buf); i++)
6898 {
6899 GET_OP (buf[i]);
6900 if ((buf[i] & 0x80) == 0)
6901 break;
6902 }
6903 assert (i < sizeof (buf));
6904 offset = read_uleb128 (buf, &len);
6905 assert (len == i + 1);
6906 offset = offset * 8 + 0x408;
6907 printf (_("sp = sp + %ld"), offset);
6908 }
6909 else if ((op & 0xf0) == 0xe0)
6910 {
6911 if ((op & 0x0f) == 7)
6912 printf (" RETURN");
6913 else
6914 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6915 }
6916 else
6917 {
6918 printf (_(" [unsupported opcode]"));
6919 }
6920 putchar ('\n');
6921 }
6922}
6923
6924static bfd_vma
a734115a 6925arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 6926{
6927 bfd_vma offset;
6928
6929 offset = word & 0x7fffffff;
6930 if (offset & 0x40000000)
6931 offset |= ~ (bfd_vma) 0x7fffffff;
6932
6933 if (elf_header.e_machine == EM_TI_C6000)
6934 offset <<= 1;
6935
6936 return offset + where;
6937}
6938
6939static void
1b31d05e
NC		 6940decode_arm_unwind (struct arm_unw_aux_info * aux,
6941 unsigned int word,
6942 unsigned int remaining,
6943 bfd_vma data_offset,
6944 Elf_Internal_Shdr * data_sec,
6945 struct arm_section * data_arm_sec)
fa197c1c
PB		 6946{
6947 int per_index;
6948 unsigned int more_words = 0;
6949 struct absaddr addr;
1b31d05e 6950 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 6951
6952 if (remaining == 0)
6953 {
1b31d05e
NC		 6954 /* Fetch the first word.
6955 Note - when decoding an object file the address extracted
6956 here will always be 0. So we also pass in the sym_name
6957 parameter so that we can find the symbol associated with
6958 the personality routine. */
6959 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
6960 & word, & addr, & sym_name))
fa197c1c 6961 return;
1b31d05e 6962
fa197c1c
PB		 6963 remaining = 4;
6964 }
6965
6966 if ((word & 0x80000000) == 0)
6967 {
6968 /* Expand prel31 for personality routine. */
6969 bfd_vma fn;
6970 const char *procname;
6971
a734115a 6972 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 6973 printf (_(" Personality routine: "));
1b31d05e
NC		 6974 if (fn == 0
6975 && addr.section == SHN_UNDEF && addr.offset == 0
6976 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
6977 {
6978 procname = aux->strtab + sym_name;
6979 print_vma (fn, PREFIX_HEX);
6980 if (procname)
6981 {
6982 fputs (" <", stdout);
6983 fputs (procname, stdout);
6984 fputc ('>', stdout);
6985 }
6986 }
6987 else
6988 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 6989 fputc ('\n', stdout);
6990
6991 /* The GCC personality routines use the standard compact
6992 encoding, starting with one byte giving the number of
6993 words. */
6994 if (procname != NULL
6995 && (const_strneq (procname, "__gcc_personality_v0")
6996 || const_strneq (procname, "__gxx_personality_v0")
6997 || const_strneq (procname, "__gcj_personality_v0")
6998 || const_strneq (procname, "__gnu_objc_personality_v0")))
6999 {
7000 remaining = 0;
7001 more_words = 1;
7002 ADVANCE;
7003 if (!remaining)
7004 {
7005 printf (_(" [Truncated data]\n"));
7006 return;
7007 }
7008 more_words = word >> 24;
7009 word <<= 8;
7010 remaining--;
7011 per_index = -1;
7012 }
7013 else
7014 return;
7015 }
7016 else
7017 {
1b31d05e
NC		 7018 /* ARM EHABI Section 6.3:
7019
7020 An exception-handling table entry for the compact model looks like:
7021
7022 31 30-28 27-24 23-0
7023 -- ----- ----- ----
7024 1 0 index Data for personalityRoutine[index] */
7025
7026 if (elf_header.e_machine == EM_ARM
7027 && (word & 0x70000000))
83c257ca 7028 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 7029
fa197c1c 7030 per_index = (word >> 24) & 0x7f;
1b31d05e 7031 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 7032 if (per_index == 0)
7033 {
7034 more_words = 0;
7035 word <<= 8;
7036 remaining--;
7037 }
7038 else if (per_index < 3)
7039 {
7040 more_words = (word >> 16) & 0xff;
7041 word <<= 16;
7042 remaining -= 2;
7043 }
7044 }
7045
7046 switch (elf_header.e_machine)
7047 {
7048 case EM_ARM:
7049 if (per_index < 3)
7050 {
7051 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7052 data_offset, data_sec, data_arm_sec);
7053 }
7054 else
1b31d05e
NC		 7055 {
7056 warn (_("Unknown ARM compact model index encountered\n"));
7057 printf (_(" [reserved]\n"));
7058 }
fa197c1c
PB		 7059 break;
7060
7061 case EM_TI_C6000:
7062 if (per_index < 3)
7063 {
7064 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 7065 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 7066 }
7067 else if (per_index < 5)
7068 {
7069 if (((word >> 17) & 0x7f) == 0x7f)
7070 printf (_(" Restore stack from frame pointer\n"));
7071 else
7072 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7073 printf (_(" Registers restored: "));
7074 if (per_index == 4)
7075 printf (" (compact) ");
7076 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7077 putchar ('\n');
7078 printf (_(" Return register: %s\n"),
7079 tic6x_unwind_regnames[word & 0xf]);
7080 }
7081 else
1b31d05e 7082 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 7083 break;
7084
7085 default:
1b31d05e
NC		 7086 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7087 elf_header.e_machine);
fa197c1c 7088 }
0b6ae522
DJ		 7089
7090 /* Decode the descriptors. Not implemented. */
7091}
7092
7093static void
7094dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7095{
7096 struct arm_section exidx_arm_sec, extab_arm_sec;
7097 unsigned int i, exidx_len;
7098
7099 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7100 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7101 exidx_len = exidx_sec->sh_size / 8;
7102
7103 for (i = 0; i < exidx_len; i++)
7104 {
7105 unsigned int exidx_fn, exidx_entry;
7106 struct absaddr fn_addr, entry_addr;
7107 bfd_vma fn;
7108
7109 fputc ('\n', stdout);
7110
1b31d05e
NC		 7111 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7112 8 * i, & exidx_fn, & fn_addr, NULL)
7113 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7114 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 7115 {
1b31d05e
NC		 7116 arm_free_section (& exidx_arm_sec);
7117 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 7118 return;
7119 }
7120
83c257ca
NC		 7121 /* ARM EHABI, Section 5:
7122 An index table entry consists of 2 words.
7123 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7124 if (exidx_fn & 0x80000000)
7125 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7126
a734115a 7127 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 7128
a734115a 7129 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 7130 fputs (": ", stdout);
7131
7132 if (exidx_entry == 1)
7133 {
7134 print_vma (exidx_entry, PREFIX_HEX);
7135 fputs (" [cantunwind]\n", stdout);
7136 }
7137 else if (exidx_entry & 0x80000000)
7138 {
7139 print_vma (exidx_entry, PREFIX_HEX);
7140 fputc ('\n', stdout);
7141 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7142 }
7143 else
7144 {
8f73510c 7145 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 7146 Elf_Internal_Shdr *table_sec;
7147
7148 fputs ("@", stdout);
a734115a 7149 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 7150 print_vma (table, PREFIX_HEX);
7151 printf ("\n");
7152
7153 /* Locate the matching .ARM.extab. */
7154 if (entry_addr.section != SHN_UNDEF
7155 && entry_addr.section < elf_header.e_shnum)
7156 {
7157 table_sec = section_headers + entry_addr.section;
7158 table_offset = entry_addr.offset;
7159 }
7160 else
7161 {
7162 table_sec = find_section_by_address (table);
7163 if (table_sec != NULL)
7164 table_offset = table - table_sec->sh_addr;
7165 }
7166 if (table_sec == NULL)
7167 {
7168 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7169 (unsigned long) table);
7170 continue;
7171 }
7172 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7173 &extab_arm_sec);
7174 }
7175 }
7176
7177 printf ("\n");
7178
7179 arm_free_section (&exidx_arm_sec);
7180 arm_free_section (&extab_arm_sec);
7181}
7182
fa197c1c 7183/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 7184
7185static void
0b6ae522
DJ		 7186arm_process_unwind (FILE *file)
7187{
7188 struct arm_unw_aux_info aux;
7189 Elf_Internal_Shdr *unwsec = NULL;
7190 Elf_Internal_Shdr *strsec;
7191 Elf_Internal_Shdr *sec;
7192 unsigned long i;
fa197c1c 7193 unsigned int sec_type;
0b6ae522 7194
fa197c1c
PB		 7195 switch (elf_header.e_machine)
7196 {
7197 case EM_ARM:
7198 sec_type = SHT_ARM_EXIDX;
7199 break;
7200
7201 case EM_TI_C6000:
7202 sec_type = SHT_C6000_UNWIND;
7203 break;
7204
1b31d05e
NC		 7205 default:
7206 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7207 elf_header.e_machine);
7208 return;
fa197c1c
PB		 7209 }
7210
0b6ae522 7211 if (string_table == NULL)
1b31d05e
NC		 7212 return;
7213
7214 memset (& aux, 0, sizeof (aux));
7215 aux.file = file;
0b6ae522
DJ		 7216
7217 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7218 {
7219 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7220 {
ba5cdace 7221 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 7222
7223 strsec = section_headers + sec->sh_link;
59245841 7224 assert (aux.strtab == NULL);
0b6ae522
DJ		 7225 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7226 1, strsec->sh_size, _("string table"));
7227 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7228 }
fa197c1c 7229 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 7230 unwsec = sec;
7231 }
7232
1b31d05e 7233 if (unwsec == NULL)
0b6ae522 7234 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 7235 else
7236 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7237 {
7238 if (sec->sh_type == sec_type)
7239 {
7240 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7241 SECTION_NAME (sec),
7242 (unsigned long) sec->sh_offset,
7243 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 7244
1b31d05e
NC		 7245 dump_arm_unwind (&aux, sec);
7246 }
7247 }
0b6ae522
DJ		 7248
7249 if (aux.symtab)
7250 free (aux.symtab);
7251 if (aux.strtab)
7252 free ((char *) aux.strtab);
0b6ae522
DJ		 7253}
7254
1b31d05e 7255static void
2cf0635d 7256process_unwind (FILE * file)
57346661 7257{
2cf0635d
NC		 7258 struct unwind_handler
7259 {
57346661 7260 int machtype;
1b31d05e 7261 void (* handler)(FILE *);
2cf0635d
NC		 7262 } handlers[] =
7263 {
0b6ae522 7264 { EM_ARM, arm_process_unwind },
57346661
AM		 7265 { EM_IA_64, ia64_process_unwind },
7266 { EM_PARISC, hppa_process_unwind },
fa197c1c 7267 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 7268 { 0, 0 }
7269 };
7270 int i;
7271
7272 if (!do_unwind)
1b31d05e 7273 return;
57346661
AM		 7274
7275 for (i = 0; handlers[i].handler != NULL; i++)
7276 if (elf_header.e_machine == handlers[i].machtype)
18bd398b 7277 return handlers[i].handler (file);
57346661 7278
1b31d05e
NC		 7279 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7280 get_machine_name (elf_header.e_machine));
57346661
AM		 7281}
7282
252b5132 7283static void
2cf0635d 7284dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 7285{
7286 switch (entry->d_tag)
7287 {
7288 case DT_MIPS_FLAGS:
7289 if (entry->d_un.d_val == 0)
4b68bca3 7290 printf (_("NONE"));
252b5132
RH		 7291 else
7292 {
7293 static const char * opts[] =
7294 {
7295 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7296 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7297 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7298 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7299 "RLD_ORDER_SAFE"
7300 };
7301 unsigned int cnt;
7302 int first = 1;
2b692964 7303
60bca95a 7304 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 7305 if (entry->d_un.d_val & (1 << cnt))
7306 {
7307 printf ("%s%s", first ? "" : " ", opts[cnt]);
7308 first = 0;
7309 }
252b5132
RH		 7310 }
7311 break;
103f02d3 7312
252b5132 7313 case DT_MIPS_IVERSION:
d79b3d50 7314 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 7315 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7316 else
4b68bca3 7317 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
252b5132 7318 break;
103f02d3 7319
252b5132
RH		 7320 case DT_MIPS_TIME_STAMP:
7321 {
7322 char timebuf[20];
2cf0635d 7323 struct tm * tmp;
50da7a9c 7324
91d6fa6a
NC		 7325 time_t atime = entry->d_un.d_val;
7326 tmp = gmtime (&atime);
e9e44622
JJ		 7327 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7328 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7329 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 7330 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 7331 }
7332 break;
103f02d3 7333
252b5132
RH		 7334 case DT_MIPS_RLD_VERSION:
7335 case DT_MIPS_LOCAL_GOTNO:
7336 case DT_MIPS_CONFLICTNO:
7337 case DT_MIPS_LIBLISTNO:
7338 case DT_MIPS_SYMTABNO:
7339 case DT_MIPS_UNREFEXTNO:
7340 case DT_MIPS_HIPAGENO:
7341 case DT_MIPS_DELTA_CLASS_NO:
7342 case DT_MIPS_DELTA_INSTANCE_NO:
7343 case DT_MIPS_DELTA_RELOC_NO:
7344 case DT_MIPS_DELTA_SYM_NO:
7345 case DT_MIPS_DELTA_CLASSSYM_NO:
7346 case DT_MIPS_COMPACT_SIZE:
4b68bca3 7347 print_vma (entry->d_un.d_ptr, DEC);
252b5132 7348 break;
103f02d3
UD		 7349
7350 default:
4b68bca3 7351 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 7352 }
4b68bca3 7353 putchar ('\n');
103f02d3
UD		 7354}
7355
103f02d3 7356static void
2cf0635d 7357dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 7358{
7359 switch (entry->d_tag)
7360 {
7361 case DT_HP_DLD_FLAGS:
7362 {
7363 static struct
7364 {
7365 long int bit;
2cf0635d 7366 const char * str;
5e220199
NC		 7367 }
7368 flags[] =
7369 {
7370 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7371 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7372 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7373 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7374 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7375 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7376 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7377 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7378 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7379 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 7380 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7381 { DT_HP_GST, "HP_GST" },
7382 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7383 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7384 { DT_HP_NODELETE, "HP_NODELETE" },
7385 { DT_HP_GROUP, "HP_GROUP" },
7386 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 7387 };
103f02d3 7388 int first = 1;
5e220199 7389 size_t cnt;
f7a99963 7390 bfd_vma val = entry->d_un.d_val;
103f02d3 7391
60bca95a 7392 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 7393 if (val & flags[cnt].bit)
30800947
NC		 7394 {
7395 if (! first)
7396 putchar (' ');
7397 fputs (flags[cnt].str, stdout);
7398 first = 0;
7399 val ^= flags[cnt].bit;
7400 }
76da6bbe 7401
103f02d3 7402 if (val != 0 || first)
f7a99963
NC		 7403 {
7404 if (! first)
7405 putchar (' ');
7406 print_vma (val, HEX);
7407 }
103f02d3
UD		 7408 }
7409 break;
76da6bbe 7410
252b5132 7411 default:
f7a99963
NC		 7412 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7413 break;
252b5132 7414 }
35b1837e 7415 putchar ('\n');
252b5132
RH		 7416}
7417
28f997cf
TG		 7418#ifdef BFD64
7419
7420/* VMS vs Unix time offset and factor. */
7421
7422#define VMS_EPOCH_OFFSET 35067168000000000LL
7423#define VMS_GRANULARITY_FACTOR 10000000
7424
7425/* Display a VMS time in a human readable format. */
7426
7427static void
7428print_vms_time (bfd_int64_t vmstime)
7429{
7430 struct tm *tm;
7431 time_t unxtime;
7432
7433 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7434 tm = gmtime (&unxtime);
7435 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7436 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7437 tm->tm_hour, tm->tm_min, tm->tm_sec);
7438}
7439#endif /* BFD64 */
7440
ecc51f48 7441static void
2cf0635d 7442dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 7443{
7444 switch (entry->d_tag)
7445 {
0de14b54 7446 case DT_IA_64_PLT_RESERVE:
bdf4d63a 7447 /* First 3 slots reserved. */
ecc51f48
NC		 7448 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7449 printf (" -- ");
7450 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 7451 break;
7452
28f997cf
TG		 7453 case DT_IA_64_VMS_LINKTIME:
7454#ifdef BFD64
7455 print_vms_time (entry->d_un.d_val);
7456#endif
7457 break;
7458
7459 case DT_IA_64_VMS_LNKFLAGS:
7460 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7461 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7462 printf (" CALL_DEBUG");
7463 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7464 printf (" NOP0BUFS");
7465 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7466 printf (" P0IMAGE");
7467 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7468 printf (" MKTHREADS");
7469 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7470 printf (" UPCALLS");
7471 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7472 printf (" IMGSTA");
7473 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7474 printf (" INITIALIZE");
7475 if (entry->d_un.d_val & VMS_LF_MAIN)
7476 printf (" MAIN");
7477 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7478 printf (" EXE_INIT");
7479 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7480 printf (" TBK_IN_IMG");
7481 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7482 printf (" DBG_IN_IMG");
7483 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7484 printf (" TBK_IN_DSF");
7485 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7486 printf (" DBG_IN_DSF");
7487 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7488 printf (" SIGNATURES");
7489 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7490 printf (" REL_SEG_OFF");
7491 break;
7492
bdf4d63a
JJ		 7493 default:
7494 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7495 break;
ecc51f48 7496 }
bdf4d63a 7497 putchar ('\n');
ecc51f48
NC		 7498}
7499
252b5132 7500static int
2cf0635d 7501get_32bit_dynamic_section (FILE * file)
252b5132 7502{
2cf0635d
NC		 7503 Elf32_External_Dyn * edyn;
7504 Elf32_External_Dyn * ext;
7505 Elf_Internal_Dyn * entry;
103f02d3 7506
3f5e193b
NC		 7507 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7508 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7509 if (!edyn)
7510 return 0;
103f02d3 7511
ba2685cc
AM		 7512/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7513 might not have the luxury of section headers. Look for the DT_NULL
7514 terminator to determine the number of entries. */
7515 for (ext = edyn, dynamic_nent = 0;
7516 (char *) ext < (char *) edyn + dynamic_size;
7517 ext++)
7518 {
7519 dynamic_nent++;
7520 if (BYTE_GET (ext->d_tag) == DT_NULL)
7521 break;
7522 }
252b5132 7523
3f5e193b
NC		 7524 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7525 sizeof (* entry));
b2d38a17 7526 if (dynamic_section == NULL)
252b5132 7527 {
9ea033b2
NC		 7528 error (_("Out of memory\n"));
7529 free (edyn);
7530 return 0;
7531 }
252b5132 7532
fb514b26 7533 for (ext = edyn, entry = dynamic_section;
ba2685cc 7534 entry < dynamic_section + dynamic_nent;
fb514b26 7535 ext++, entry++)
9ea033b2 7536 {
fb514b26
AM		 7537 entry->d_tag = BYTE_GET (ext->d_tag);
7538 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7539 }
7540
9ea033b2
NC		 7541 free (edyn);
7542
7543 return 1;
7544}
7545
7546static int
2cf0635d 7547get_64bit_dynamic_section (FILE * file)
9ea033b2 7548{
2cf0635d
NC		 7549 Elf64_External_Dyn * edyn;
7550 Elf64_External_Dyn * ext;
7551 Elf_Internal_Dyn * entry;
103f02d3 7552
3f5e193b
NC		 7553 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7554 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 7555 if (!edyn)
7556 return 0;
103f02d3 7557
ba2685cc
AM		 7558/* SGI's ELF has more than one section in the DYNAMIC segment, and we
7559 might not have the luxury of section headers. Look for the DT_NULL
7560 terminator to determine the number of entries. */
7561 for (ext = edyn, dynamic_nent = 0;
7562 (char *) ext < (char *) edyn + dynamic_size;
7563 ext++)
7564 {
7565 dynamic_nent++;
66543521 7566 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 7567 break;
7568 }
252b5132 7569
3f5e193b
NC		 7570 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7571 sizeof (* entry));
b2d38a17 7572 if (dynamic_section == NULL)
252b5132
RH		 7573 {
7574 error (_("Out of memory\n"));
7575 free (edyn);
7576 return 0;
7577 }
7578
fb514b26 7579 for (ext = edyn, entry = dynamic_section;
ba2685cc 7580 entry < dynamic_section + dynamic_nent;
fb514b26 7581 ext++, entry++)
252b5132 7582 {
66543521
AM		 7583 entry->d_tag = BYTE_GET (ext->d_tag);
7584 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 7585 }
7586
7587 free (edyn);
7588
9ea033b2
NC		 7589 return 1;
7590}
7591
e9e44622
JJ		 7592static void
7593print_dynamic_flags (bfd_vma flags)
d1133906 7594{
e9e44622 7595 int first = 1;
13ae64f3 7596
d1133906
NC		 7597 while (flags)
7598 {
7599 bfd_vma flag;
7600
7601 flag = flags & - flags;
7602 flags &= ~ flag;
7603
e9e44622
JJ		 7604 if (first)
7605 first = 0;
7606 else
7607 putc (' ', stdout);
13ae64f3 7608
d1133906
NC		 7609 switch (flag)
7610 {
e9e44622
JJ		 7611 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7612 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7613 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7614 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7615 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 7616 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 7617 }
7618 }
e9e44622 7619 puts ("");
d1133906
NC		 7620}
7621
b2d38a17
NC		 7622/* Parse and display the contents of the dynamic section. */
7623
9ea033b2 7624static int
2cf0635d 7625process_dynamic_section (FILE * file)
9ea033b2 7626{
2cf0635d 7627 Elf_Internal_Dyn * entry;
9ea033b2
NC		 7628
7629 if (dynamic_size == 0)
7630 {
7631 if (do_dynamic)
b2d38a17 7632 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 7633
7634 return 1;
7635 }
7636
7637 if (is_32bit_elf)
7638 {
b2d38a17 7639 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 7640 return 0;
7641 }
b2d38a17 7642 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 7643 return 0;
7644
252b5132
RH		 7645 /* Find the appropriate symbol table. */
7646 if (dynamic_symbols == NULL)
7647 {
86dba8ee
AM		 7648 for (entry = dynamic_section;
7649 entry < dynamic_section + dynamic_nent;
7650 ++entry)
252b5132 7651 {
c8286bd1 7652 Elf_Internal_Shdr section;
252b5132
RH		 7653
7654 if (entry->d_tag != DT_SYMTAB)
7655 continue;
7656
7657 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7658
7659 /* Since we do not know how big the symbol table is,
7660 we default to reading in the entire file (!) and
7661 processing that. This is overkill, I know, but it
e3c8793a 7662 should work. */
d93f0186 7663 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 7664
fb52b2f4
NC		 7665 if (archive_file_offset != 0)
7666 section.sh_size = archive_file_size - section.sh_offset;
7667 else
7668 {
7669 if (fseek (file, 0, SEEK_END))
591a748a 7670 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 7671
7672 section.sh_size = ftell (file) - section.sh_offset;
7673 }
252b5132 7674
9ea033b2 7675 if (is_32bit_elf)
9ad5cbcf 7676 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 7677 else
9ad5cbcf 7678 section.sh_entsize = sizeof (Elf64_External_Sym);
252b5132 7679
ba5cdace 7680 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 7681 if (num_dynamic_syms < 1)
252b5132
RH		 7682 {
7683 error (_("Unable to determine the number of symbols to load\n"));
7684 continue;
7685 }
252b5132
RH		 7686 }
7687 }
7688
7689 /* Similarly find a string table. */
7690 if (dynamic_strings == NULL)
7691 {
86dba8ee
AM		 7692 for (entry = dynamic_section;
7693 entry < dynamic_section + dynamic_nent;
7694 ++entry)
252b5132
RH		 7695 {
7696 unsigned long offset;
b34976b6 7697 long str_tab_len;
252b5132
RH		 7698
7699 if (entry->d_tag != DT_STRTAB)
7700 continue;
7701
7702 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7703
7704 /* Since we do not know how big the string table is,
7705 we default to reading in the entire file (!) and
7706 processing that. This is overkill, I know, but it
e3c8793a 7707 should work. */
252b5132 7708
d93f0186 7709 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 7710
7711 if (archive_file_offset != 0)
7712 str_tab_len = archive_file_size - offset;
7713 else
7714 {
7715 if (fseek (file, 0, SEEK_END))
7716 error (_("Unable to seek to end of file\n"));
7717 str_tab_len = ftell (file) - offset;
7718 }
252b5132
RH		 7719
7720 if (str_tab_len < 1)
7721 {
7722 error
7723 (_("Unable to determine the length of the dynamic string table\n"));
7724 continue;
7725 }
7726
3f5e193b
NC		 7727 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7728 str_tab_len,
7729 _("dynamic string table"));
59245841 7730 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 7731 break;
7732 }
7733 }
7734
7735 /* And find the syminfo section if available. */
7736 if (dynamic_syminfo == NULL)
7737 {
3e8bba36 7738 unsigned long syminsz = 0;
252b5132 7739
86dba8ee
AM		 7740 for (entry = dynamic_section;
7741 entry < dynamic_section + dynamic_nent;
7742 ++entry)
252b5132
RH		 7743 {
7744 if (entry->d_tag == DT_SYMINENT)
7745 {
7746 /* Note: these braces are necessary to avoid a syntax
7747 error from the SunOS4 C compiler. */
7748 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7749 }
7750 else if (entry->d_tag == DT_SYMINSZ)
7751 syminsz = entry->d_un.d_val;
7752 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 7753 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7754 syminsz);
252b5132
RH		 7755 }
7756
7757 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7758 {
2cf0635d
NC		 7759 Elf_External_Syminfo * extsyminfo;
7760 Elf_External_Syminfo * extsym;
7761 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 7762
7763 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 7764 extsyminfo = (Elf_External_Syminfo *)
7765 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7766 _("symbol information"));
a6e9f9df
AM		 7767 if (!extsyminfo)
7768 return 0;
252b5132 7769
3f5e193b 7770 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 7771 if (dynamic_syminfo == NULL)
7772 {
7773 error (_("Out of memory\n"));
7774 return 0;
7775 }
7776
7777 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 7778 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7779 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7780 ++syminfo, ++extsym)
252b5132 7781 {
86dba8ee
AM		 7782 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7783 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 7784 }
7785
7786 free (extsyminfo);
7787 }
7788 }
7789
7790 if (do_dynamic && dynamic_addr)
86dba8ee
AM		 7791 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7792 dynamic_addr, dynamic_nent);
252b5132
RH		 7793 if (do_dynamic)
7794 printf (_(" Tag Type Name/Value\n"));
7795
86dba8ee
AM		 7796 for (entry = dynamic_section;
7797 entry < dynamic_section + dynamic_nent;
7798 entry++)
252b5132
RH		 7799 {
7800 if (do_dynamic)
f7a99963 7801 {
2cf0635d 7802 const char * dtype;
e699b9ff 7803
f7a99963
NC		 7804 putchar (' ');
7805 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 7806 dtype = get_dynamic_type (entry->d_tag);
7807 printf (" (%s)%*s", dtype,
7808 ((is_32bit_elf ? 27 : 19)
7809 - (int) strlen (dtype)),
f7a99963
NC		 7810 " ");
7811 }
252b5132
RH		 7812
7813 switch (entry->d_tag)
7814 {
d1133906
NC		 7815 case DT_FLAGS:
7816 if (do_dynamic)
e9e44622 7817 print_dynamic_flags (entry->d_un.d_val);
d1133906 7818 break;
76da6bbe 7819
252b5132
RH		 7820 case DT_AUXILIARY:
7821 case DT_FILTER:
019148e4
L		 7822 case DT_CONFIG:
7823 case DT_DEPAUDIT:
7824 case DT_AUDIT:
252b5132
RH		 7825 if (do_dynamic)
7826 {
019148e4 7827 switch (entry->d_tag)
b34976b6 7828 {
019148e4
L		 7829 case DT_AUXILIARY:
7830 printf (_("Auxiliary library"));
7831 break;
7832
7833 case DT_FILTER:
7834 printf (_("Filter library"));
7835 break;
7836
b34976b6 7837 case DT_CONFIG:
019148e4
L		 7838 printf (_("Configuration file"));
7839 break;
7840
7841 case DT_DEPAUDIT:
7842 printf (_("Dependency audit library"));
7843 break;
7844
7845 case DT_AUDIT:
7846 printf (_("Audit library"));
7847 break;
7848 }
252b5132 7849
d79b3d50
NC		 7850 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7851 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 7852 else
f7a99963
NC		 7853 {
7854 printf (": ");
7855 print_vma (entry->d_un.d_val, PREFIX_HEX);
7856 putchar ('\n');
7857 }
252b5132
RH		 7858 }
7859 break;
7860
dcefbbbd 7861 case DT_FEATURE:
252b5132
RH		 7862 if (do_dynamic)
7863 {
7864 printf (_("Flags:"));
86f55779 7865
252b5132
RH		 7866 if (entry->d_un.d_val == 0)
7867 printf (_(" None\n"));
7868 else
7869 {
7870 unsigned long int val = entry->d_un.d_val;
86f55779 7871
252b5132
RH		 7872 if (val & DTF_1_PARINIT)
7873 {
7874 printf (" PARINIT");
7875 val ^= DTF_1_PARINIT;
7876 }
dcefbbbd
L		 7877 if (val & DTF_1_CONFEXP)
7878 {
7879 printf (" CONFEXP");
7880 val ^= DTF_1_CONFEXP;
7881 }
252b5132
RH		 7882 if (val != 0)
7883 printf (" %lx", val);
7884 puts ("");
7885 }
7886 }
7887 break;
7888
7889 case DT_POSFLAG_1:
7890 if (do_dynamic)
7891 {
7892 printf (_("Flags:"));
86f55779 7893
252b5132
RH		 7894 if (entry->d_un.d_val == 0)
7895 printf (_(" None\n"));
7896 else
7897 {
7898 unsigned long int val = entry->d_un.d_val;
86f55779 7899
252b5132
RH		 7900 if (val & DF_P1_LAZYLOAD)
7901 {
7902 printf (" LAZYLOAD");
7903 val ^= DF_P1_LAZYLOAD;
7904 }
7905 if (val & DF_P1_GROUPPERM)
7906 {
7907 printf (" GROUPPERM");
7908 val ^= DF_P1_GROUPPERM;
7909 }
7910 if (val != 0)
7911 printf (" %lx", val);
7912 puts ("");
7913 }
7914 }
7915 break;
7916
7917 case DT_FLAGS_1:
7918 if (do_dynamic)
7919 {
7920 printf (_("Flags:"));
7921 if (entry->d_un.d_val == 0)
7922 printf (_(" None\n"));
7923 else
7924 {
7925 unsigned long int val = entry->d_un.d_val;
86f55779 7926
252b5132
RH		 7927 if (val & DF_1_NOW)
7928 {
7929 printf (" NOW");
7930 val ^= DF_1_NOW;
7931 }
7932 if (val & DF_1_GLOBAL)
7933 {
7934 printf (" GLOBAL");
7935 val ^= DF_1_GLOBAL;
7936 }
7937 if (val & DF_1_GROUP)
7938 {
7939 printf (" GROUP");
7940 val ^= DF_1_GROUP;
7941 }
7942 if (val & DF_1_NODELETE)
7943 {
7944 printf (" NODELETE");
7945 val ^= DF_1_NODELETE;
7946 }
7947 if (val & DF_1_LOADFLTR)
7948 {
7949 printf (" LOADFLTR");
7950 val ^= DF_1_LOADFLTR;
7951 }
7952 if (val & DF_1_INITFIRST)
7953 {
7954 printf (" INITFIRST");
7955 val ^= DF_1_INITFIRST;
7956 }
7957 if (val & DF_1_NOOPEN)
7958 {
7959 printf (" NOOPEN");
7960 val ^= DF_1_NOOPEN;
7961 }
7962 if (val & DF_1_ORIGIN)
7963 {
7964 printf (" ORIGIN");
7965 val ^= DF_1_ORIGIN;
7966 }
7967 if (val & DF_1_DIRECT)
7968 {
7969 printf (" DIRECT");
7970 val ^= DF_1_DIRECT;
7971 }
7972 if (val & DF_1_TRANS)
7973 {
7974 printf (" TRANS");
7975 val ^= DF_1_TRANS;
7976 }
7977 if (val & DF_1_INTERPOSE)
7978 {
7979 printf (" INTERPOSE");
7980 val ^= DF_1_INTERPOSE;
7981 }
f7db6139 7982 if (val & DF_1_NODEFLIB)
dcefbbbd 7983 {
f7db6139
L		 7984 printf (" NODEFLIB");
7985 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 7986 }
7987 if (val & DF_1_NODUMP)
7988 {
7989 printf (" NODUMP");
7990 val ^= DF_1_NODUMP;
7991 }
7992 if (val & DF_1_CONLFAT)
7993 {
7994 printf (" CONLFAT");
7995 val ^= DF_1_CONLFAT;
7996 }
252b5132
RH		 7997 if (val != 0)
7998 printf (" %lx", val);
7999 puts ("");
8000 }
8001 }
8002 break;
8003
8004 case DT_PLTREL:
566b0d53 8005 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8006 if (do_dynamic)
8007 puts (get_dynamic_type (entry->d_un.d_val));
8008 break;
8009
8010 case DT_NULL :
8011 case DT_NEEDED :
8012 case DT_PLTGOT :
8013 case DT_HASH :
8014 case DT_STRTAB :
8015 case DT_SYMTAB :
8016 case DT_RELA :
8017 case DT_INIT :
8018 case DT_FINI :
8019 case DT_SONAME :
8020 case DT_RPATH :
8021 case DT_SYMBOLIC:
8022 case DT_REL :
8023 case DT_DEBUG :
8024 case DT_TEXTREL :
8025 case DT_JMPREL :
019148e4 8026 case DT_RUNPATH :
252b5132
RH		 8027 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8028
8029 if (do_dynamic)
8030 {
2cf0635d 8031 char * name;
252b5132 8032
d79b3d50
NC		 8033 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8034 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8035 else
d79b3d50 8036 name = NULL;
252b5132
RH		 8037
8038 if (name)
8039 {
8040 switch (entry->d_tag)
8041 {
8042 case DT_NEEDED:
8043 printf (_("Shared library: [%s]"), name);
8044
18bd398b 8045 if (streq (name, program_interpreter))
f7a99963 8046 printf (_(" program interpreter"));
252b5132
RH		 8047 break;
8048
8049 case DT_SONAME:
f7a99963 8050 printf (_("Library soname: [%s]"), name);
252b5132
RH		 8051 break;
8052
8053 case DT_RPATH:
f7a99963 8054 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 8055 break;
8056
019148e4
L		 8057 case DT_RUNPATH:
8058 printf (_("Library runpath: [%s]"), name);
8059 break;
8060
252b5132 8061 default:
f7a99963
NC		 8062 print_vma (entry->d_un.d_val, PREFIX_HEX);
8063 break;
252b5132
RH		 8064 }
8065 }
8066 else
f7a99963
NC		 8067 print_vma (entry->d_un.d_val, PREFIX_HEX);
8068
8069 putchar ('\n');
252b5132
RH		 8070 }
8071 break;
8072
8073 case DT_PLTRELSZ:
8074 case DT_RELASZ :
8075 case DT_STRSZ :
8076 case DT_RELSZ :
8077 case DT_RELAENT :
8078 case DT_SYMENT :
8079 case DT_RELENT :
566b0d53 8080 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 8081 case DT_PLTPADSZ:
8082 case DT_MOVEENT :
8083 case DT_MOVESZ :
8084 case DT_INIT_ARRAYSZ:
8085 case DT_FINI_ARRAYSZ:
047b2264
JJ		 8086 case DT_GNU_CONFLICTSZ:
8087 case DT_GNU_LIBLISTSZ:
252b5132 8088 if (do_dynamic)
f7a99963
NC		 8089 {
8090 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 8091 printf (_(" (bytes)\n"));
f7a99963 8092 }
252b5132
RH		 8093 break;
8094
8095 case DT_VERDEFNUM:
8096 case DT_VERNEEDNUM:
8097 case DT_RELACOUNT:
8098 case DT_RELCOUNT:
8099 if (do_dynamic)
f7a99963
NC		 8100 {
8101 print_vma (entry->d_un.d_val, UNSIGNED);
8102 putchar ('\n');
8103 }
252b5132
RH		 8104 break;
8105
8106 case DT_SYMINSZ:
8107 case DT_SYMINENT:
8108 case DT_SYMINFO:
8109 case DT_USED:
8110 case DT_INIT_ARRAY:
8111 case DT_FINI_ARRAY:
8112 if (do_dynamic)
8113 {
d79b3d50
NC		 8114 if (entry->d_tag == DT_USED
8115 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 8116 {
2cf0635d 8117 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 8118
b34976b6 8119 if (*name)
252b5132
RH		 8120 {
8121 printf (_("Not needed object: [%s]\n"), name);
8122 break;
8123 }
8124 }
103f02d3 8125
f7a99963
NC		 8126 print_vma (entry->d_un.d_val, PREFIX_HEX);
8127 putchar ('\n');
252b5132
RH		 8128 }
8129 break;
8130
8131 case DT_BIND_NOW:
8132 /* The value of this entry is ignored. */
35b1837e
AM		 8133 if (do_dynamic)
8134 putchar ('\n');
252b5132 8135 break;
103f02d3 8136
047b2264
JJ		 8137 case DT_GNU_PRELINKED:
8138 if (do_dynamic)
8139 {
2cf0635d 8140 struct tm * tmp;
91d6fa6a 8141 time_t atime = entry->d_un.d_val;
047b2264 8142
91d6fa6a 8143 tmp = gmtime (&atime);
047b2264
JJ		 8144 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8145 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8146 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8147
8148 }
8149 break;
8150
fdc90cb4
JJ		 8151 case DT_GNU_HASH:
8152 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8153 if (do_dynamic)
8154 {
8155 print_vma (entry->d_un.d_val, PREFIX_HEX);
8156 putchar ('\n');
8157 }
8158 break;
8159
252b5132
RH		 8160 default:
8161 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 8162 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 8163 entry->d_un.d_val;
8164
8165 if (do_dynamic)
8166 {
8167 switch (elf_header.e_machine)
8168 {
8169 case EM_MIPS:
4fe85591 8170 case EM_MIPS_RS3_LE:
b2d38a17 8171 dynamic_section_mips_val (entry);
252b5132 8172 break;
103f02d3 8173 case EM_PARISC:
b2d38a17 8174 dynamic_section_parisc_val (entry);
103f02d3 8175 break;
ecc51f48 8176 case EM_IA_64:
b2d38a17 8177 dynamic_section_ia64_val (entry);
ecc51f48 8178 break;
252b5132 8179 default:
f7a99963
NC		 8180 print_vma (entry->d_un.d_val, PREFIX_HEX);
8181 putchar ('\n');
252b5132
RH		 8182 }
8183 }
8184 break;
8185 }
8186 }
8187
8188 return 1;
8189}
8190
8191static char *
d3ba0551 8192get_ver_flags (unsigned int flags)
252b5132 8193{
b34976b6 8194 static char buff[32];
252b5132
RH		 8195
8196 buff[0] = 0;
8197
8198 if (flags == 0)
8199 return _("none");
8200
8201 if (flags & VER_FLG_BASE)
8202 strcat (buff, "BASE ");
8203
8204 if (flags & VER_FLG_WEAK)
8205 {
8206 if (flags & VER_FLG_BASE)
8207 strcat (buff, "| ");
8208
8209 strcat (buff, "WEAK ");
8210 }
8211
44ec90b9
RO		 8212 if (flags & VER_FLG_INFO)
8213 {
8214 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8215 strcat (buff, "| ");
8216
8217 strcat (buff, "INFO ");
8218 }
8219
8220 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 8221 strcat (buff, _("| <unknown>"));
252b5132
RH		 8222
8223 return buff;
8224}
8225
8226/* Display the contents of the version sections. */
98fb390a 8227
252b5132 8228static int
2cf0635d 8229process_version_sections (FILE * file)
252b5132 8230{
2cf0635d 8231 Elf_Internal_Shdr * section;
b34976b6
AM		 8232 unsigned i;
8233 int found = 0;
252b5132
RH		 8234
8235 if (! do_version)
8236 return 1;
8237
8238 for (i = 0, section = section_headers;
8239 i < elf_header.e_shnum;
b34976b6 8240 i++, section++)
252b5132
RH		 8241 {
8242 switch (section->sh_type)
8243 {
8244 case SHT_GNU_verdef:
8245 {
2cf0635d 8246 Elf_External_Verdef * edefs;
b34976b6
AM		 8247 unsigned int idx;
8248 unsigned int cnt;
2cf0635d 8249 char * endbuf;
252b5132
RH		 8250
8251 found = 1;
8252
8253 printf
72de5009 8254 (_("\nVersion definition section '%s' contains %u entries:\n"),
252b5132
RH		 8255 SECTION_NAME (section), section->sh_info);
8256
8257 printf (_(" Addr: 0x"));
8258 printf_vma (section->sh_addr);
72de5009 8259 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8260 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8261 section->sh_link < elf_header.e_shnum
8262 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8263 : _("<corrupt>"));
252b5132 8264
3f5e193b
NC		 8265 edefs = (Elf_External_Verdef *)
8266 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8267 _("version definition section"));
a6e9f9df
AM		 8268 if (!edefs)
8269 break;
59245841 8270 endbuf = (char *) edefs + section->sh_size;
252b5132 8271
b34976b6 8272 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 8273 {
2cf0635d
NC		 8274 char * vstart;
8275 Elf_External_Verdef * edef;
b34976b6 8276 Elf_Internal_Verdef ent;
2cf0635d 8277 Elf_External_Verdaux * eaux;
b34976b6
AM		 8278 Elf_Internal_Verdaux aux;
8279 int j;
8280 int isum;
103f02d3 8281
dd24e3da
NC		 8282 /* Check for negative or very large indicies. */
8283 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8284 break;
8285
252b5132 8286 vstart = ((char *) edefs) + idx;
54806181
AM		 8287 if (vstart + sizeof (*edef) > endbuf)
8288 break;
252b5132
RH		 8289
8290 edef = (Elf_External_Verdef *) vstart;
8291
8292 ent.vd_version = BYTE_GET (edef->vd_version);
8293 ent.vd_flags = BYTE_GET (edef->vd_flags);
8294 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8295 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8296 ent.vd_hash = BYTE_GET (edef->vd_hash);
8297 ent.vd_aux = BYTE_GET (edef->vd_aux);
8298 ent.vd_next = BYTE_GET (edef->vd_next);
8299
8300 printf (_(" %#06x: Rev: %d Flags: %s"),
8301 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8302
8303 printf (_(" Index: %d Cnt: %d "),
8304 ent.vd_ndx, ent.vd_cnt);
8305
dd24e3da
NC		 8306 /* Check for overflow. */
8307 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8308 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8309 break;
8310
252b5132
RH		 8311 vstart += ent.vd_aux;
8312
8313 eaux = (Elf_External_Verdaux *) vstart;
8314
8315 aux.vda_name = BYTE_GET (eaux->vda_name);
8316 aux.vda_next = BYTE_GET (eaux->vda_next);
8317
d79b3d50
NC		 8318 if (VALID_DYNAMIC_NAME (aux.vda_name))
8319 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8320 else
8321 printf (_("Name index: %ld\n"), aux.vda_name);
8322
8323 isum = idx + ent.vd_aux;
8324
b34976b6 8325 for (j = 1; j < ent.vd_cnt; j++)
252b5132 8326 {
dd24e3da
NC		 8327 /* Check for overflow. */
8328 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8329 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8330 break;
8331
252b5132
RH		 8332 isum += aux.vda_next;
8333 vstart += aux.vda_next;
8334
8335 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 8336 if (vstart + sizeof (*eaux) > endbuf)
8337 break;
252b5132
RH		 8338
8339 aux.vda_name = BYTE_GET (eaux->vda_name);
8340 aux.vda_next = BYTE_GET (eaux->vda_next);
8341
d79b3d50 8342 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 8343 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 8344 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 8345 else
8346 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8347 isum, j, aux.vda_name);
8348 }
dd24e3da 8349
54806181
AM		 8350 if (j < ent.vd_cnt)
8351 printf (_(" Version def aux past end of section\n"));
252b5132
RH		 8352
8353 idx += ent.vd_next;
8354 }
dd24e3da 8355
54806181
AM		 8356 if (cnt < section->sh_info)
8357 printf (_(" Version definition past end of section\n"));
252b5132
RH		 8358
8359 free (edefs);
8360 }
8361 break;
103f02d3 8362
252b5132
RH		 8363 case SHT_GNU_verneed:
8364 {
2cf0635d 8365 Elf_External_Verneed * eneed;
b34976b6
AM		 8366 unsigned int idx;
8367 unsigned int cnt;
2cf0635d 8368 char * endbuf;
252b5132
RH		 8369
8370 found = 1;
8371
72de5009 8372 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
252b5132
RH		 8373 SECTION_NAME (section), section->sh_info);
8374
8375 printf (_(" Addr: 0x"));
8376 printf_vma (section->sh_addr);
72de5009 8377 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8378 (unsigned long) section->sh_offset, section->sh_link,
4fbb74a6
AM		 8379 section->sh_link < elf_header.e_shnum
8380 ? SECTION_NAME (section_headers + section->sh_link)
2b692964 8381 : _("<corrupt>"));
252b5132 8382
3f5e193b
NC		 8383 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8384 section->sh_offset, 1,
8385 section->sh_size,
9cf03b7e 8386 _("Version Needs section"));
a6e9f9df
AM		 8387 if (!eneed)
8388 break;
59245841 8389 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 8390
8391 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8392 {
2cf0635d 8393 Elf_External_Verneed * entry;
b34976b6
AM		 8394 Elf_Internal_Verneed ent;
8395 int j;
8396 int isum;
2cf0635d 8397 char * vstart;
252b5132 8398
dd24e3da
NC		 8399 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8400 break;
8401
252b5132 8402 vstart = ((char *) eneed) + idx;
54806181
AM		 8403 if (vstart + sizeof (*entry) > endbuf)
8404 break;
252b5132
RH		 8405
8406 entry = (Elf_External_Verneed *) vstart;
8407
8408 ent.vn_version = BYTE_GET (entry->vn_version);
8409 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8410 ent.vn_file = BYTE_GET (entry->vn_file);
8411 ent.vn_aux = BYTE_GET (entry->vn_aux);
8412 ent.vn_next = BYTE_GET (entry->vn_next);
8413
8414 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8415
d79b3d50
NC		 8416 if (VALID_DYNAMIC_NAME (ent.vn_file))
8417 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 8418 else
8419 printf (_(" File: %lx"), ent.vn_file);
8420
8421 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8422
dd24e3da
NC		 8423 /* Check for overflow. */
8424 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8425 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8426 break;
8427
252b5132
RH		 8428 vstart += ent.vn_aux;
8429
8430 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8431 {
2cf0635d 8432 Elf_External_Vernaux * eaux;
b34976b6 8433 Elf_Internal_Vernaux aux;
252b5132 8434
54806181
AM		 8435 if (vstart + sizeof (*eaux) > endbuf)
8436 break;
252b5132
RH		 8437 eaux = (Elf_External_Vernaux *) vstart;
8438
8439 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8440 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8441 aux.vna_other = BYTE_GET (eaux->vna_other);
8442 aux.vna_name = BYTE_GET (eaux->vna_name);
8443 aux.vna_next = BYTE_GET (eaux->vna_next);
8444
d79b3d50 8445 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 8446 printf (_(" %#06x: Name: %s"),
d79b3d50 8447 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 8448 else
ecc2063b 8449 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 8450 isum, aux.vna_name);
8451
8452 printf (_(" Flags: %s Version: %d\n"),
8453 get_ver_flags (aux.vna_flags), aux.vna_other);
8454
dd24e3da
NC		 8455 /* Check for overflow. */
8456 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8457 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8458 break;
8459
252b5132
RH		 8460 isum += aux.vna_next;
8461 vstart += aux.vna_next;
8462 }
9cf03b7e 8463
54806181 8464 if (j < ent.vn_cnt)
9cf03b7e 8465 warn (_("Missing Version Needs auxillary information\n"));
252b5132
RH		 8466
8467 idx += ent.vn_next;
8468 }
9cf03b7e 8469
54806181 8470 if (cnt < section->sh_info)
9cf03b7e 8471 warn (_("Missing Version Needs information\n"));
103f02d3 8472
252b5132
RH		 8473 free (eneed);
8474 }
8475 break;
8476
8477 case SHT_GNU_versym:
8478 {
2cf0635d 8479 Elf_Internal_Shdr * link_section;
b34976b6
AM		 8480 int total;
8481 int cnt;
2cf0635d
NC		 8482 unsigned char * edata;
8483 unsigned short * data;
8484 char * strtab;
8485 Elf_Internal_Sym * symbols;
8486 Elf_Internal_Shdr * string_sec;
ba5cdace 8487 unsigned long num_syms;
d3ba0551 8488 long off;
252b5132 8489
4fbb74a6 8490 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8491 break;
8492
4fbb74a6 8493 link_section = section_headers + section->sh_link;
08d8fa11 8494 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 8495
4fbb74a6 8496 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 8497 break;
8498
252b5132
RH		 8499 found = 1;
8500
ba5cdace 8501 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 8502 if (symbols == NULL)
8503 break;
252b5132 8504
4fbb74a6 8505 string_sec = section_headers + link_section->sh_link;
252b5132 8506
3f5e193b
NC		 8507 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8508 string_sec->sh_size,
8509 _("version string table"));
a6e9f9df 8510 if (!strtab)
0429c154
MS		 8511 {
8512 free (symbols);
8513 break;
8514 }
252b5132
RH		 8515
8516 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8517 SECTION_NAME (section), total);
8518
8519 printf (_(" Addr: "));
8520 printf_vma (section->sh_addr);
72de5009 8521 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 8522 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 8523 SECTION_NAME (link_section));
8524
d3ba0551
AM		 8525 off = offset_from_vma (file,
8526 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8527 total * sizeof (short));
3f5e193b
NC		 8528 edata = (unsigned char *) get_data (NULL, file, off, total,
8529 sizeof (short),
8530 _("version symbol data"));
a6e9f9df
AM		 8531 if (!edata)
8532 {
8533 free (strtab);
0429c154 8534 free (symbols);
a6e9f9df
AM		 8535 break;
8536 }
252b5132 8537
3f5e193b 8538 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 8539
8540 for (cnt = total; cnt --;)
b34976b6
AM		 8541 data[cnt] = byte_get (edata + cnt * sizeof (short),
8542 sizeof (short));
252b5132
RH		 8543
8544 free (edata);
8545
8546 for (cnt = 0; cnt < total; cnt += 4)
8547 {
8548 int j, nn;
00d93f34 8549 int check_def, check_need;
2cf0635d 8550 char * name;
252b5132
RH		 8551
8552 printf (" %03x:", cnt);
8553
8554 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 8555 switch (data[cnt + j])
252b5132
RH		 8556 {
8557 case 0:
8558 fputs (_(" 0 (*local*) "), stdout);
8559 break;
8560
8561 case 1:
8562 fputs (_(" 1 (*global*) "), stdout);
8563 break;
8564
8565 default:
c244d050
NC		 8566 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8567 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 8568
dd24e3da 8569 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 8570 array, break to avoid an out-of-bounds read. */
8571 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 8572 {
8573 warn (_("invalid index into symbol array\n"));
8574 break;
8575 }
8576
00d93f34
JJ		 8577 check_def = 1;
8578 check_need = 1;
4fbb74a6
AM		 8579 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8580 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 8581 != SHT_NOBITS)
252b5132 8582 {
b34976b6 8583 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 8584 check_def = 0;
8585 else
8586 check_need = 0;
252b5132 8587 }
00d93f34
JJ		 8588
8589 if (check_need
b34976b6 8590 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 8591 {
b34976b6
AM		 8592 Elf_Internal_Verneed ivn;
8593 unsigned long offset;
252b5132 8594
d93f0186
NC		 8595 offset = offset_from_vma
8596 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8597 sizeof (Elf_External_Verneed));
252b5132 8598
b34976b6 8599 do
252b5132 8600 {
b34976b6
AM		 8601 Elf_Internal_Vernaux ivna;
8602 Elf_External_Verneed evn;
8603 Elf_External_Vernaux evna;
8604 unsigned long a_off;
252b5132 8605
59245841
NC		 8606 if (get_data (&evn, file, offset, sizeof (evn), 1,
8607 _("version need")) == NULL)
8608 break;
8609
252b5132
RH		 8610 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8611 ivn.vn_next = BYTE_GET (evn.vn_next);
8612
8613 a_off = offset + ivn.vn_aux;
8614
8615 do
8616 {
59245841
NC		 8617 if (get_data (&evna, file, a_off, sizeof (evna),
8618 1, _("version need aux (2)")) == NULL)
8619 {
8620 ivna.vna_next = 0;
8621 ivna.vna_other = 0;
8622 }
8623 else
8624 {
8625 ivna.vna_next = BYTE_GET (evna.vna_next);
8626 ivna.vna_other = BYTE_GET (evna.vna_other);
8627 }
252b5132
RH		 8628
8629 a_off += ivna.vna_next;
8630 }
b34976b6 8631 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 8632 && ivna.vna_next != 0);
8633
b34976b6 8634 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 8635 {
8636 ivna.vna_name = BYTE_GET (evna.vna_name);
8637
54806181
AM		 8638 if (ivna.vna_name >= string_sec->sh_size)
8639 name = _("*invalid*");
8640 else
8641 name = strtab + ivna.vna_name;
252b5132 8642 nn += printf ("(%s%-*s",
16062207
ILT		 8643 name,
8644 12 - (int) strlen (name),
252b5132 8645 ")");
00d93f34 8646 check_def = 0;
252b5132
RH		 8647 break;
8648 }
8649
8650 offset += ivn.vn_next;
8651 }
8652 while (ivn.vn_next);
8653 }
00d93f34 8654
b34976b6
AM		 8655 if (check_def && data[cnt + j] != 0x8001
8656 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 8657 {
b34976b6
AM		 8658 Elf_Internal_Verdef ivd;
8659 Elf_External_Verdef evd;
8660 unsigned long offset;
252b5132 8661
d93f0186
NC		 8662 offset = offset_from_vma
8663 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8664 sizeof evd);
252b5132
RH		 8665
8666 do
8667 {
59245841
NC		 8668 if (get_data (&evd, file, offset, sizeof (evd), 1,
8669 _("version def")) == NULL)
8670 {
8671 ivd.vd_next = 0;
8672 ivd.vd_ndx = 0;
8673 }
8674 else
8675 {
8676 ivd.vd_next = BYTE_GET (evd.vd_next);
8677 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8678 }
252b5132
RH		 8679
8680 offset += ivd.vd_next;
8681 }
c244d050 8682 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 8683 && ivd.vd_next != 0);
8684
c244d050 8685 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 8686 {
b34976b6
AM		 8687 Elf_External_Verdaux evda;
8688 Elf_Internal_Verdaux ivda;
252b5132
RH		 8689
8690 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8691
59245841
NC		 8692 if (get_data (&evda, file,
8693 offset - ivd.vd_next + ivd.vd_aux,
8694 sizeof (evda), 1,
8695 _("version def aux")) == NULL)
8696 break;
252b5132
RH		 8697
8698 ivda.vda_name = BYTE_GET (evda.vda_name);
8699
54806181
AM		 8700 if (ivda.vda_name >= string_sec->sh_size)
8701 name = _("*invalid*");
8702 else
8703 name = strtab + ivda.vda_name;
252b5132 8704 nn += printf ("(%s%-*s",
16062207
ILT		 8705 name,
8706 12 - (int) strlen (name),
252b5132
RH		 8707 ")");
8708 }
8709 }
8710
8711 if (nn < 18)
8712 printf ("%*c", 18 - nn, ' ');
8713 }
8714
8715 putchar ('\n');
8716 }
8717
8718 free (data);
8719 free (strtab);
8720 free (symbols);
8721 }
8722 break;
103f02d3 8723
252b5132
RH		 8724 default:
8725 break;
8726 }
8727 }
8728
8729 if (! found)
8730 printf (_("\nNo version information found in this file.\n"));
8731
8732 return 1;
8733}
8734
d1133906 8735static const char *
d3ba0551 8736get_symbol_binding (unsigned int binding)
252b5132 8737{
b34976b6 8738 static char buff[32];
252b5132
RH		 8739
8740 switch (binding)
8741 {
b34976b6
AM		 8742 case STB_LOCAL: return "LOCAL";
8743 case STB_GLOBAL: return "GLOBAL";
8744 case STB_WEAK: return "WEAK";
252b5132
RH		 8745 default:
8746 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 8747 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8748 binding);
252b5132 8749 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 8750 {
8751 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 8752 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8753 /* GNU is still using the default value 0. */
3e7a7d11
NC		 8754 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8755 return "UNIQUE";
8756 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8757 }
252b5132 8758 else
e9e44622 8759 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 8760 return buff;
8761 }
8762}
8763
d1133906 8764static const char *
d3ba0551 8765get_symbol_type (unsigned int type)
252b5132 8766{
b34976b6 8767 static char buff[32];
252b5132
RH		 8768
8769 switch (type)
8770 {
b34976b6
AM		 8771 case STT_NOTYPE: return "NOTYPE";
8772 case STT_OBJECT: return "OBJECT";
8773 case STT_FUNC: return "FUNC";
8774 case STT_SECTION: return "SECTION";
8775 case STT_FILE: return "FILE";
8776 case STT_COMMON: return "COMMON";
8777 case STT_TLS: return "TLS";
15ab5209
DB		 8778 case STT_RELC: return "RELC";
8779 case STT_SRELC: return "SRELC";
252b5132
RH		 8780 default:
8781 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 8782 {
8783 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 8784 return "THUMB_FUNC";
8785
351b4b40 8786 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 8787 return "REGISTER";
8788
8789 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8790 return "PARISC_MILLI";
8791
e9e44622 8792 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 8793 }
252b5132 8794 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 8795 {
8796 if (elf_header.e_machine == EM_PARISC)
8797 {
8798 if (type == STT_HP_OPAQUE)
8799 return "HP_OPAQUE";
8800 if (type == STT_HP_STUB)
8801 return "HP_STUB";
8802 }
8803
d8045f23 8804 if (type == STT_GNU_IFUNC
9c55345c 8805 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 8806 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 8807 /* GNU is still using the default value 0. */
d8045f23
NC		 8808 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8809 return "IFUNC";
8810
e9e44622 8811 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 8812 }
252b5132 8813 else
e9e44622 8814 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 8815 return buff;
8816 }
8817}
8818
d1133906 8819static const char *
d3ba0551 8820get_symbol_visibility (unsigned int visibility)
d1133906
NC		 8821{
8822 switch (visibility)
8823 {
b34976b6
AM		 8824 case STV_DEFAULT: return "DEFAULT";
8825 case STV_INTERNAL: return "INTERNAL";
8826 case STV_HIDDEN: return "HIDDEN";
d1133906
NC		 8827 case STV_PROTECTED: return "PROTECTED";
8828 default: abort ();
8829 }
8830}
8831
5e2b0d47
NC		 8832static const char *
8833get_mips_symbol_other (unsigned int other)
8834{
8835 switch (other)
8836 {
df58fc94
RS		 8837 case STO_OPTIONAL:
8838 return "OPTIONAL";
8839 case STO_MIPS_PLT:
8840 return "MIPS PLT";
8841 case STO_MIPS_PIC:
8842 return "MIPS PIC";
8843 case STO_MICROMIPS:
8844 return "MICROMIPS";
8845 case STO_MICROMIPS | STO_MIPS_PIC:
8846 return "MICROMIPS, MIPS PIC";
8847 case STO_MIPS16:
8848 return "MIPS16";
8849 default:
8850 return NULL;
5e2b0d47
NC		 8851 }
8852}
8853
28f997cf
TG		 8854static const char *
8855get_ia64_symbol_other (unsigned int other)
8856{
8857 if (is_ia64_vms ())
8858 {
8859 static char res[32];
8860
8861 res[0] = 0;
8862
8863 /* Function types is for images and .STB files only. */
8864 switch (elf_header.e_type)
8865 {
8866 case ET_DYN:
8867 case ET_EXEC:
8868 switch (VMS_ST_FUNC_TYPE (other))
8869 {
8870 case VMS_SFT_CODE_ADDR:
8871 strcat (res, " CA");
8872 break;
8873 case VMS_SFT_SYMV_IDX:
8874 strcat (res, " VEC");
8875 break;
8876 case VMS_SFT_FD:
8877 strcat (res, " FD");
8878 break;
8879 case VMS_SFT_RESERVE:
8880 strcat (res, " RSV");
8881 break;
8882 default:
8883 abort ();
8884 }
8885 break;
8886 default:
8887 break;
8888 }
8889 switch (VMS_ST_LINKAGE (other))
8890 {
8891 case VMS_STL_IGNORE:
8892 strcat (res, " IGN");
8893 break;
8894 case VMS_STL_RESERVE:
8895 strcat (res, " RSV");
8896 break;
8897 case VMS_STL_STD:
8898 strcat (res, " STD");
8899 break;
8900 case VMS_STL_LNK:
8901 strcat (res, " LNK");
8902 break;
8903 default:
8904 abort ();
8905 }
8906
8907 if (res[0] != 0)
8908 return res + 1;
8909 else
8910 return res;
8911 }
8912 return NULL;
8913}
8914
5e2b0d47
NC		 8915static const char *
8916get_symbol_other (unsigned int other)
8917{
8918 const char * result = NULL;
8919 static char buff [32];
8920
8921 if (other == 0)
8922 return "";
8923
8924 switch (elf_header.e_machine)
8925 {
8926 case EM_MIPS:
8927 result = get_mips_symbol_other (other);
28f997cf
TG		 8928 break;
8929 case EM_IA_64:
8930 result = get_ia64_symbol_other (other);
8931 break;
5e2b0d47
NC		 8932 default:
8933 break;
8934 }
8935
8936 if (result)
8937 return result;
8938
8939 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8940 return buff;
8941}
8942
d1133906 8943static const char *
d3ba0551 8944get_symbol_index_type (unsigned int type)
252b5132 8945{
b34976b6 8946 static char buff[32];
5cf1065c 8947
252b5132
RH		 8948 switch (type)
8949 {
b34976b6
AM		 8950 case SHN_UNDEF: return "UND";
8951 case SHN_ABS: return "ABS";
8952 case SHN_COMMON: return "COM";
252b5132 8953 default:
9ce701e2
L		 8954 if (type == SHN_IA_64_ANSI_COMMON
8955 && elf_header.e_machine == EM_IA_64
8956 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8957 return "ANSI_COM";
8a9036a4 8958 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 8959 || elf_header.e_machine == EM_L1OM
8960 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 8961 && type == SHN_X86_64_LCOMMON)
8962 return "LARGE_COM";
ac145307
BS		 8963 else if ((type == SHN_MIPS_SCOMMON
8964 && elf_header.e_machine == EM_MIPS)
8965 || (type == SHN_TIC6X_SCOMMON
8966 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 8967 return "SCOM";
8968 else if (type == SHN_MIPS_SUNDEFINED
8969 && elf_header.e_machine == EM_MIPS)
8970 return "SUND";
9ce701e2 8971 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 8972 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 8973 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 8974 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8975 else if (type >= SHN_LORESERVE)
8976 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4
L		 8977 else if (type >= elf_header.e_shnum)
8978 sprintf (buff, "bad section index[%3d]", type);
252b5132 8979 else
232e7cb8 8980 sprintf (buff, "%3d", type);
5cf1065c 8981 break;
252b5132 8982 }
5cf1065c
NC		 8983
8984 return buff;
252b5132
RH		 8985}
8986
66543521 8987static bfd_vma *
2cf0635d 8988get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
252b5132 8989{
2cf0635d
NC		 8990 unsigned char * e_data;
8991 bfd_vma * i_data;
252b5132 8992
3f5e193b 8993 e_data = (unsigned char *) cmalloc (number, ent_size);
252b5132
RH		 8994
8995 if (e_data == NULL)
8996 {
8997 error (_("Out of memory\n"));
8998 return NULL;
8999 }
9000
66543521 9001 if (fread (e_data, ent_size, number, file) != number)
252b5132
RH		 9002 {
9003 error (_("Unable to read in dynamic data\n"));
9004 return NULL;
9005 }
9006
3f5e193b 9007 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
252b5132
RH		 9008
9009 if (i_data == NULL)
9010 {
9011 error (_("Out of memory\n"));
9012 free (e_data);
9013 return NULL;
9014 }
9015
9016 while (number--)
66543521 9017 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 9018
9019 free (e_data);
9020
9021 return i_data;
9022}
9023
6bd1a22c
L		 9024static void
9025print_dynamic_symbol (bfd_vma si, unsigned long hn)
9026{
2cf0635d 9027 Elf_Internal_Sym * psym;
6bd1a22c
L		 9028 int n;
9029
9030 psym = dynamic_symbols + si;
9031
9032 n = print_vma (si, DEC_5);
9033 if (n < 5)
9034 fputs (" " + n, stdout);
9035 printf (" %3lu: ", hn);
9036 print_vma (psym->st_value, LONG_HEX);
9037 putchar (' ');
9038 print_vma (psym->st_size, DEC_5);
9039
f4be36b3
AM		 9040 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9041 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9042 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 9043 /* Check to see if any other bits in the st_other field are set.
9044 Note - displaying this information disrupts the layout of the
9045 table being generated, but for the moment this case is very
9046 rare. */
9047 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9048 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9049 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9050 if (VALID_DYNAMIC_NAME (psym->st_name))
9051 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9052 else
2b692964 9053 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 9054 putchar ('\n');
9055}
9056
e3c8793a 9057/* Dump the symbol table. */
252b5132 9058static int
2cf0635d 9059process_symbol_table (FILE * file)
252b5132 9060{
2cf0635d 9061 Elf_Internal_Shdr * section;
66543521
AM		 9062 bfd_vma nbuckets = 0;
9063 bfd_vma nchains = 0;
2cf0635d
NC		 9064 bfd_vma * buckets = NULL;
9065 bfd_vma * chains = NULL;
fdc90cb4 9066 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 9067 bfd_vma * gnubuckets = NULL;
9068 bfd_vma * gnuchains = NULL;
6bd1a22c 9069 bfd_vma gnusymidx = 0;
252b5132 9070
2c610e4b 9071 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 9072 return 1;
9073
6bd1a22c
L		 9074 if (dynamic_info[DT_HASH]
9075 && (do_histogram
2c610e4b
L		 9076 || (do_using_dynamic
9077 && !do_dyn_syms
9078 && dynamic_strings != NULL)))
252b5132 9079 {
66543521
AM		 9080 unsigned char nb[8];
9081 unsigned char nc[8];
9082 int hash_ent_size = 4;
9083
9084 if ((elf_header.e_machine == EM_ALPHA
9085 || elf_header.e_machine == EM_S390
9086 || elf_header.e_machine == EM_S390_OLD)
9087 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9088 hash_ent_size = 8;
9089
fb52b2f4
NC		 9090 if (fseek (file,
9091 (archive_file_offset
9092 + offset_from_vma (file, dynamic_info[DT_HASH],
9093 sizeof nb + sizeof nc)),
d93f0186 9094 SEEK_SET))
252b5132 9095 {
591a748a 9096 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9097 goto no_hash;
252b5132
RH		 9098 }
9099
66543521 9100 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 9101 {
9102 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9103 goto no_hash;
252b5132
RH		 9104 }
9105
66543521 9106 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 9107 {
9108 error (_("Failed to read in number of chains\n"));
d3a44ec6 9109 goto no_hash;
252b5132
RH		 9110 }
9111
66543521
AM		 9112 nbuckets = byte_get (nb, hash_ent_size);
9113 nchains = byte_get (nc, hash_ent_size);
252b5132 9114
66543521
AM		 9115 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9116 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 9117
d3a44ec6 9118 no_hash:
252b5132 9119 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 9120 {
9121 if (do_using_dynamic)
9122 return 0;
9123 free (buckets);
9124 free (chains);
9125 buckets = NULL;
9126 chains = NULL;
9127 nbuckets = 0;
9128 nchains = 0;
9129 }
252b5132
RH		 9130 }
9131
6bd1a22c
L		 9132 if (dynamic_info_DT_GNU_HASH
9133 && (do_histogram
2c610e4b
L		 9134 || (do_using_dynamic
9135 && !do_dyn_syms
9136 && dynamic_strings != NULL)))
252b5132 9137 {
6bd1a22c
L		 9138 unsigned char nb[16];
9139 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9140 bfd_vma buckets_vma;
9141
9142 if (fseek (file,
9143 (archive_file_offset
9144 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9145 sizeof nb)),
9146 SEEK_SET))
9147 {
9148 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9149 goto no_gnu_hash;
6bd1a22c 9150 }
252b5132 9151
6bd1a22c
L		 9152 if (fread (nb, 16, 1, file) != 1)
9153 {
9154 error (_("Failed to read in number of buckets\n"));
d3a44ec6 9155 goto no_gnu_hash;
6bd1a22c
L		 9156 }
9157
9158 ngnubuckets = byte_get (nb, 4);
9159 gnusymidx = byte_get (nb + 4, 4);
9160 bitmaskwords = byte_get (nb + 8, 4);
9161 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 9162 if (is_32bit_elf)
6bd1a22c 9163 buckets_vma += bitmaskwords * 4;
f7a99963 9164 else
6bd1a22c 9165 buckets_vma += bitmaskwords * 8;
252b5132 9166
6bd1a22c
L		 9167 if (fseek (file,
9168 (archive_file_offset
9169 + offset_from_vma (file, buckets_vma, 4)),
9170 SEEK_SET))
252b5132 9171 {
6bd1a22c 9172 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9173 goto no_gnu_hash;
6bd1a22c
L		 9174 }
9175
9176 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 9177
6bd1a22c 9178 if (gnubuckets == NULL)
d3a44ec6 9179 goto no_gnu_hash;
6bd1a22c
L		 9180
9181 for (i = 0; i < ngnubuckets; i++)
9182 if (gnubuckets[i] != 0)
9183 {
9184 if (gnubuckets[i] < gnusymidx)
9185 return 0;
9186
9187 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9188 maxchain = gnubuckets[i];
9189 }
9190
9191 if (maxchain == 0xffffffff)
d3a44ec6 9192 goto no_gnu_hash;
6bd1a22c
L		 9193
9194 maxchain -= gnusymidx;
9195
9196 if (fseek (file,
9197 (archive_file_offset
9198 + offset_from_vma (file, buckets_vma
9199 + 4 * (ngnubuckets + maxchain), 4)),
9200 SEEK_SET))
9201 {
9202 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9203 goto no_gnu_hash;
6bd1a22c
L		 9204 }
9205
9206 do
9207 {
9208 if (fread (nb, 4, 1, file) != 1)
252b5132 9209 {
6bd1a22c 9210 error (_("Failed to determine last chain length\n"));
d3a44ec6 9211 goto no_gnu_hash;
6bd1a22c 9212 }
252b5132 9213
6bd1a22c 9214 if (maxchain + 1 == 0)
d3a44ec6 9215 goto no_gnu_hash;
252b5132 9216
6bd1a22c
L		 9217 ++maxchain;
9218 }
9219 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 9220
6bd1a22c
L		 9221 if (fseek (file,
9222 (archive_file_offset
9223 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9224 SEEK_SET))
9225 {
9226 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 9227 goto no_gnu_hash;
6bd1a22c
L		 9228 }
9229
9230 gnuchains = get_dynamic_data (file, maxchain, 4);
9231
d3a44ec6 9232 no_gnu_hash:
6bd1a22c 9233 if (gnuchains == NULL)
d3a44ec6
JJ		 9234 {
9235 free (gnubuckets);
d3a44ec6
JJ		 9236 gnubuckets = NULL;
9237 ngnubuckets = 0;
f64fddf1
NC		 9238 if (do_using_dynamic)
9239 return 0;
d3a44ec6 9240 }
6bd1a22c
L		 9241 }
9242
9243 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9244 && do_syms
9245 && do_using_dynamic
9246 && dynamic_strings != NULL)
9247 {
9248 unsigned long hn;
9249
9250 if (dynamic_info[DT_HASH])
9251 {
9252 bfd_vma si;
9253
9254 printf (_("\nSymbol table for image:\n"));
9255 if (is_32bit_elf)
9256 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9257 else
9258 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9259
9260 for (hn = 0; hn < nbuckets; hn++)
9261 {
9262 if (! buckets[hn])
9263 continue;
9264
9265 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9266 print_dynamic_symbol (si, hn);
252b5132
RH		 9267 }
9268 }
6bd1a22c
L		 9269
9270 if (dynamic_info_DT_GNU_HASH)
9271 {
9272 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9273 if (is_32bit_elf)
9274 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9275 else
9276 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9277
9278 for (hn = 0; hn < ngnubuckets; ++hn)
9279 if (gnubuckets[hn] != 0)
9280 {
9281 bfd_vma si = gnubuckets[hn];
9282 bfd_vma off = si - gnusymidx;
9283
9284 do
9285 {
9286 print_dynamic_symbol (si, hn);
9287 si++;
9288 }
9289 while ((gnuchains[off++] & 1) == 0);
9290 }
9291 }
252b5132 9292 }
2c610e4b 9293 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
252b5132 9294 {
b34976b6 9295 unsigned int i;
252b5132
RH		 9296
9297 for (i = 0, section = section_headers;
9298 i < elf_header.e_shnum;
9299 i++, section++)
9300 {
b34976b6 9301 unsigned int si;
2cf0635d 9302 char * strtab = NULL;
c256ffe7 9303 unsigned long int strtab_size = 0;
2cf0635d
NC		 9304 Elf_Internal_Sym * symtab;
9305 Elf_Internal_Sym * psym;
ba5cdace 9306 unsigned long num_syms;
252b5132 9307
2c610e4b
L		 9308 if ((section->sh_type != SHT_SYMTAB
9309 && section->sh_type != SHT_DYNSYM)
9310 || (!do_syms
9311 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 9312 continue;
9313
dd24e3da
NC		 9314 if (section->sh_entsize == 0)
9315 {
9316 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9317 SECTION_NAME (section));
9318 continue;
9319 }
9320
252b5132
RH		 9321 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9322 SECTION_NAME (section),
9323 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 9324
f7a99963 9325 if (is_32bit_elf)
ca47b30c 9326 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 9327 else
ca47b30c 9328 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 9329
ba5cdace 9330 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 9331 if (symtab == NULL)
9332 continue;
9333
9334 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 9335 {
9336 strtab = string_table;
9337 strtab_size = string_table_length;
9338 }
4fbb74a6 9339 else if (section->sh_link < elf_header.e_shnum)
252b5132 9340 {
2cf0635d 9341 Elf_Internal_Shdr * string_sec;
252b5132 9342
4fbb74a6 9343 string_sec = section_headers + section->sh_link;
252b5132 9344
3f5e193b
NC		 9345 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9346 1, string_sec->sh_size,
9347 _("string table"));
c256ffe7 9348 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 9349 }
9350
ba5cdace 9351 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 9352 {
5e220199 9353 printf ("%6d: ", si);
f7a99963
NC		 9354 print_vma (psym->st_value, LONG_HEX);
9355 putchar (' ');
9356 print_vma (psym->st_size, DEC_5);
d1133906
NC		 9357 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9358 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 9359 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 9360 /* Check to see if any other bits in the st_other field are set.
9361 Note - displaying this information disrupts the layout of the
9362 table being generated, but for the moment this case is very rare. */
9363 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9364 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 9365 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 9366 print_symbol (25, psym->st_name < strtab_size
2b692964 9367 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 9368
59245841
NC		 9369 if (section->sh_type == SHT_DYNSYM
9370 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
252b5132 9371 {
b34976b6
AM		 9372 unsigned char data[2];
9373 unsigned short vers_data;
9374 unsigned long offset;
9375 int is_nobits;
9376 int check_def;
252b5132 9377
d93f0186
NC		 9378 offset = offset_from_vma
9379 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9380 sizeof data + si * sizeof (vers_data));
252b5132 9381
59245841
NC		 9382 if (get_data (&data, file, offset + si * sizeof (vers_data),
9383 sizeof (data), 1, _("version data")) == NULL)
9384 break;
252b5132
RH		 9385
9386 vers_data = byte_get (data, 2);
9387
4fbb74a6
AM		 9388 is_nobits = (psym->st_shndx < elf_header.e_shnum
9389 && section_headers[psym->st_shndx].sh_type
c256ffe7 9390 == SHT_NOBITS);
252b5132
RH		 9391
9392 check_def = (psym->st_shndx != SHN_UNDEF);
9393
c244d050 9394 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
252b5132 9395 {
b34976b6 9396 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
00d93f34 9397 && (is_nobits || ! check_def))
252b5132 9398 {
b34976b6
AM		 9399 Elf_External_Verneed evn;
9400 Elf_Internal_Verneed ivn;
9401 Elf_Internal_Vernaux ivna;
252b5132
RH		 9402
9403 /* We must test both. */
d93f0186
NC		 9404 offset = offset_from_vma
9405 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9406 sizeof evn);
252b5132 9407
252b5132
RH		 9408 do
9409 {
b34976b6 9410 unsigned long vna_off;
252b5132 9411
59245841
NC		 9412 if (get_data (&evn, file, offset, sizeof (evn), 1,
9413 _("version need")) == NULL)
9414 {
9415 ivna.vna_next = 0;
9416 ivna.vna_other = 0;
9417 ivna.vna_name = 0;
9418 break;
9419 }
dd27201e
L		 9420
9421 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9422 ivn.vn_next = BYTE_GET (evn.vn_next);
9423
252b5132
RH		 9424 vna_off = offset + ivn.vn_aux;
9425
9426 do
9427 {
b34976b6 9428 Elf_External_Vernaux evna;
252b5132 9429
59245841
NC		 9430 if (get_data (&evna, file, vna_off,
9431 sizeof (evna), 1,
9432 _("version need aux (3)")) == NULL)
9433 {
9434 ivna.vna_next = 0;
9435 ivna.vna_other = 0;
9436 ivna.vna_name = 0;
9437 }
9438 else
9439 {
9440 ivna.vna_other = BYTE_GET (evna.vna_other);
9441 ivna.vna_next = BYTE_GET (evna.vna_next);
9442 ivna.vna_name = BYTE_GET (evna.vna_name);
9443 }
252b5132
RH		 9444
9445 vna_off += ivna.vna_next;
9446 }
9447 while (ivna.vna_other != vers_data
9448 && ivna.vna_next != 0);
9449
9450 if (ivna.vna_other == vers_data)
9451 break;
9452
9453 offset += ivn.vn_next;
9454 }
9455 while (ivn.vn_next != 0);
9456
9457 if (ivna.vna_other == vers_data)
9458 {
9459 printf ("@%s (%d)",
c256ffe7 9460 ivna.vna_name < strtab_size
2b692964 9461 ? strtab + ivna.vna_name : _("<corrupt>"),
c256ffe7 9462 ivna.vna_other);
252b5132
RH		 9463 check_def = 0;
9464 }
9465 else if (! is_nobits)
591a748a 9466 error (_("bad dynamic symbol\n"));
252b5132
RH		 9467 else
9468 check_def = 1;
9469 }
9470
9471 if (check_def)
9472 {
00d93f34 9473 if (vers_data != 0x8001
b34976b6 9474 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9475 {
b34976b6
AM		 9476 Elf_Internal_Verdef ivd;
9477 Elf_Internal_Verdaux ivda;
9478 Elf_External_Verdaux evda;
91d6fa6a 9479 unsigned long off;
252b5132 9480
91d6fa6a 9481 off = offset_from_vma
d93f0186
NC		 9482 (file,
9483 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9484 sizeof (Elf_External_Verdef));
252b5132
RH		 9485
9486 do
9487 {
b34976b6 9488 Elf_External_Verdef evd;
252b5132 9489
59245841
NC		 9490 if (get_data (&evd, file, off, sizeof (evd),
9491 1, _("version def")) == NULL)
9492 {
9493 ivd.vd_ndx = 0;
9494 ivd.vd_aux = 0;
9495 ivd.vd_next = 0;
9496 }
9497 else
9498 {
9499 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9500 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9501 ivd.vd_next = BYTE_GET (evd.vd_next);
9502 }
252b5132 9503
91d6fa6a 9504 off += ivd.vd_next;
252b5132 9505 }
c244d050 9506 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
252b5132
RH		 9507 && ivd.vd_next != 0);
9508
91d6fa6a
NC		 9509 off -= ivd.vd_next;
9510 off += ivd.vd_aux;
252b5132 9511
59245841
NC		 9512 if (get_data (&evda, file, off, sizeof (evda),
9513 1, _("version def aux")) == NULL)
9514 break;
252b5132
RH		 9515
9516 ivda.vda_name = BYTE_GET (evda.vda_name);
9517
9518 if (psym->st_name != ivda.vda_name)
c244d050 9519 printf ((vers_data & VERSYM_HIDDEN)
252b5132 9520 ? "@%s" : "@@%s",
c256ffe7 9521 ivda.vda_name < strtab_size
2b692964 9522 ? strtab + ivda.vda_name : _("<corrupt>"));
252b5132
RH		 9523 }
9524 }
9525 }
9526 }
9527
9528 putchar ('\n');
9529 }
9530
9531 free (symtab);
9532 if (strtab != string_table)
9533 free (strtab);
9534 }
9535 }
9536 else if (do_syms)
9537 printf
9538 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9539
9540 if (do_histogram && buckets != NULL)
9541 {
2cf0635d
NC		 9542 unsigned long * lengths;
9543 unsigned long * counts;
66543521
AM		 9544 unsigned long hn;
9545 bfd_vma si;
9546 unsigned long maxlength = 0;
9547 unsigned long nzero_counts = 0;
9548 unsigned long nsyms = 0;
252b5132 9549
66543521
AM		 9550 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9551 (unsigned long) nbuckets);
252b5132
RH		 9552 printf (_(" Length Number %% of total Coverage\n"));
9553
3f5e193b 9554 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 9555 if (lengths == NULL)
9556 {
591a748a 9557 error (_("Out of memory\n"));
252b5132
RH		 9558 return 0;
9559 }
9560 for (hn = 0; hn < nbuckets; ++hn)
9561 {
f7a99963 9562 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 9563 {
b34976b6 9564 ++nsyms;
252b5132 9565 if (maxlength < ++lengths[hn])
b34976b6 9566 ++maxlength;
252b5132
RH		 9567 }
9568 }
9569
3f5e193b 9570 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 9571 if (counts == NULL)
9572 {
591a748a 9573 error (_("Out of memory\n"));
252b5132
RH		 9574 return 0;
9575 }
9576
9577 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 9578 ++counts[lengths[hn]];
252b5132 9579
103f02d3 9580 if (nbuckets > 0)
252b5132 9581 {
66543521
AM		 9582 unsigned long i;
9583 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 9584 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 9585 for (i = 1; i <= maxlength; ++i)
103f02d3 9586 {
66543521
AM		 9587 nzero_counts += counts[i] * i;
9588 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9589 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 9590 (nzero_counts * 100.0) / nsyms);
9591 }
252b5132
RH		 9592 }
9593
9594 free (counts);
9595 free (lengths);
9596 }
9597
9598 if (buckets != NULL)
9599 {
9600 free (buckets);
9601 free (chains);
9602 }
9603
d3a44ec6 9604 if (do_histogram && gnubuckets != NULL)
fdc90cb4 9605 {
2cf0635d
NC		 9606 unsigned long * lengths;
9607 unsigned long * counts;
fdc90cb4
JJ		 9608 unsigned long hn;
9609 unsigned long maxlength = 0;
9610 unsigned long nzero_counts = 0;
9611 unsigned long nsyms = 0;
fdc90cb4 9612
3f5e193b 9613 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 9614 if (lengths == NULL)
9615 {
591a748a 9616 error (_("Out of memory\n"));
fdc90cb4
JJ		 9617 return 0;
9618 }
9619
9620 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9621 (unsigned long) ngnubuckets);
9622 printf (_(" Length Number %% of total Coverage\n"));
9623
9624 for (hn = 0; hn < ngnubuckets; ++hn)
9625 if (gnubuckets[hn] != 0)
9626 {
9627 bfd_vma off, length = 1;
9628
6bd1a22c 9629 for (off = gnubuckets[hn] - gnusymidx;
fdc90cb4
JJ		 9630 (gnuchains[off] & 1) == 0; ++off)
9631 ++length;
9632 lengths[hn] = length;
9633 if (length > maxlength)
9634 maxlength = length;
9635 nsyms += length;
9636 }
9637
3f5e193b 9638 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 9639 if (counts == NULL)
9640 {
591a748a 9641 error (_("Out of memory\n"));
fdc90cb4
JJ		 9642 return 0;
9643 }
9644
9645 for (hn = 0; hn < ngnubuckets; ++hn)
9646 ++counts[lengths[hn]];
9647
9648 if (ngnubuckets > 0)
9649 {
9650 unsigned long j;
9651 printf (" 0 %-10lu (%5.1f%%)\n",
9652 counts[0], (counts[0] * 100.0) / ngnubuckets);
9653 for (j = 1; j <= maxlength; ++j)
9654 {
9655 nzero_counts += counts[j] * j;
9656 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9657 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9658 (nzero_counts * 100.0) / nsyms);
9659 }
9660 }
9661
9662 free (counts);
9663 free (lengths);
9664 free (gnubuckets);
9665 free (gnuchains);
9666 }
9667
252b5132
RH		 9668 return 1;
9669}
9670
9671static int
2cf0635d 9672process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 9673{
b4c96d0d 9674 unsigned int i;
252b5132
RH		 9675
9676 if (dynamic_syminfo == NULL
9677 || !do_dynamic)
9678 /* No syminfo, this is ok. */
9679 return 1;
9680
9681 /* There better should be a dynamic symbol section. */
9682 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9683 return 0;
9684
9685 if (dynamic_addr)
9686 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9687 dynamic_syminfo_offset, dynamic_syminfo_nent);
9688
9689 printf (_(" Num: Name BoundTo Flags\n"));
9690 for (i = 0; i < dynamic_syminfo_nent; ++i)
9691 {
9692 unsigned short int flags = dynamic_syminfo[i].si_flags;
9693
31104126 9694 printf ("%4d: ", i);
d79b3d50
NC		 9695 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9696 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9697 else
2b692964 9698 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 9699 putchar (' ');
252b5132
RH		 9700
9701 switch (dynamic_syminfo[i].si_boundto)
9702 {
9703 case SYMINFO_BT_SELF:
9704 fputs ("SELF ", stdout);
9705 break;
9706 case SYMINFO_BT_PARENT:
9707 fputs ("PARENT ", stdout);
9708 break;
9709 default:
9710 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 9711 && dynamic_syminfo[i].si_boundto < dynamic_nent
9712 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 9713 {
d79b3d50 9714 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 9715 putchar (' ' );
9716 }
252b5132
RH		 9717 else
9718 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9719 break;
9720 }
9721
9722 if (flags & SYMINFO_FLG_DIRECT)
9723 printf (" DIRECT");
9724 if (flags & SYMINFO_FLG_PASSTHRU)
9725 printf (" PASSTHRU");
9726 if (flags & SYMINFO_FLG_COPY)
9727 printf (" COPY");
9728 if (flags & SYMINFO_FLG_LAZYLOAD)
9729 printf (" LAZYLOAD");
9730
9731 puts ("");
9732 }
9733
9734 return 1;
9735}
9736
cf13d699
NC		 9737/* Check to see if the given reloc needs to be handled in a target specific
9738 manner. If so then process the reloc and return TRUE otherwise return
9739 FALSE. */
09c11c86 9740
cf13d699
NC		 9741static bfd_boolean
9742target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9743 unsigned char * start,
9744 Elf_Internal_Sym * symtab)
252b5132 9745{
cf13d699 9746 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 9747
cf13d699 9748 switch (elf_header.e_machine)
252b5132 9749 {
cf13d699
NC		 9750 case EM_MN10300:
9751 case EM_CYGNUS_MN10300:
9752 {
9753 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 9754
cf13d699
NC		 9755 switch (reloc_type)
9756 {
9757 case 34: /* R_MN10300_ALIGN */
9758 return TRUE;
9759 case 33: /* R_MN10300_SYM_DIFF */
9760 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9761 return TRUE;
9762 case 1: /* R_MN10300_32 */
9763 case 2: /* R_MN10300_16 */
9764 if (saved_sym != NULL)
9765 {
9766 bfd_vma value;
252b5132 9767
cf13d699
NC		 9768 value = reloc->r_addend
9769 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9770 - saved_sym->st_value);
252b5132 9771
cf13d699 9772 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 9773
cf13d699
NC		 9774 saved_sym = NULL;
9775 return TRUE;
9776 }
9777 break;
9778 default:
9779 if (saved_sym != NULL)
9780 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9781 break;
9782 }
9783 break;
9784 }
252b5132
RH		 9785 }
9786
cf13d699 9787 return FALSE;
252b5132
RH		 9788}
9789
aca88567
NC		 9790/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9791 DWARF debug sections. This is a target specific test. Note - we do not
9792 go through the whole including-target-headers-multiple-times route, (as
9793 we have already done with <elf/h8.h>) because this would become very
9794 messy and even then this function would have to contain target specific
9795 information (the names of the relocs instead of their numeric values).
9796 FIXME: This is not the correct way to solve this problem. The proper way
9797 is to have target specific reloc sizing and typing functions created by
9798 the reloc-macros.h header, in the same way that it already creates the
9799 reloc naming functions. */
9800
9801static bfd_boolean
9802is_32bit_abs_reloc (unsigned int reloc_type)
9803{
9804 switch (elf_header.e_machine)
9805 {
41e92641
NC		 9806 case EM_386:
9807 case EM_486:
9808 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 9809 case EM_68K:
9810 return reloc_type == 1; /* R_68K_32. */
9811 case EM_860:
9812 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 9813 case EM_960:
9814 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 9815 case EM_AARCH64:
9816 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 9817 case EM_ALPHA:
137b6b5f 9818 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 9819 case EM_ARC:
9820 return reloc_type == 1; /* R_ARC_32. */
9821 case EM_ARM:
9822 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 9823 case EM_AVR_OLD:
aca88567
NC		 9824 case EM_AVR:
9825 return reloc_type == 1;
cfb8c092
NC		 9826 case EM_ADAPTEVA_EPIPHANY:
9827 return reloc_type == 3;
aca88567
NC		 9828 case EM_BLACKFIN:
9829 return reloc_type == 0x12; /* R_byte4_data. */
9830 case EM_CRIS:
9831 return reloc_type == 3; /* R_CRIS_32. */
9832 case EM_CR16:
9833 return reloc_type == 3; /* R_CR16_NUM32. */
9834 case EM_CRX:
9835 return reloc_type == 15; /* R_CRX_NUM32. */
9836 case EM_CYGNUS_FRV:
9837 return reloc_type == 1;
41e92641
NC		 9838 case EM_CYGNUS_D10V:
9839 case EM_D10V:
9840 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 9841 case EM_CYGNUS_D30V:
9842 case EM_D30V:
9843 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 9844 case EM_DLX:
9845 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 9846 case EM_CYGNUS_FR30:
9847 case EM_FR30:
9848 return reloc_type == 3; /* R_FR30_32. */
9849 case EM_H8S:
9850 case EM_H8_300:
9851 case EM_H8_300H:
9852 return reloc_type == 1; /* R_H8_DIR32. */
3730236a
NC		 9853 case EM_IA_64:
9854 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
aca88567
NC		 9855 case EM_IP2K_OLD:
9856 case EM_IP2K:
9857 return reloc_type == 2; /* R_IP2K_32. */
9858 case EM_IQ2000:
9859 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 9860 case EM_LATTICEMICO32:
9861 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 9862 case EM_M32C_OLD:
aca88567
NC		 9863 case EM_M32C:
9864 return reloc_type == 3; /* R_M32C_32. */
9865 case EM_M32R:
9866 return reloc_type == 34; /* R_M32R_32_RELA. */
9867 case EM_MCORE:
9868 return reloc_type == 1; /* R_MCORE_ADDR32. */
9869 case EM_CYGNUS_MEP:
9870 return reloc_type == 4; /* R_MEP_32. */
137b6b5f
AM		 9871 case EM_MICROBLAZE:
9872 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 9873 case EM_MIPS:
9874 return reloc_type == 2; /* R_MIPS_32. */
9875 case EM_MMIX:
9876 return reloc_type == 4; /* R_MMIX_32. */
9877 case EM_CYGNUS_MN10200:
9878 case EM_MN10200:
9879 return reloc_type == 1; /* R_MN10200_32. */
9880 case EM_CYGNUS_MN10300:
9881 case EM_MN10300:
9882 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 9883 case EM_MOXIE:
9884 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 9885 case EM_MSP430_OLD:
9886 case EM_MSP430:
9887 return reloc_type == 1; /* R_MSP43_32. */
9888 case EM_MT:
9889 return reloc_type == 2; /* R_MT_32. */
3e0873ac
NC		 9890 case EM_ALTERA_NIOS2:
9891 case EM_NIOS32:
9892 return reloc_type == 1; /* R_NIOS_32. */
41e92641
NC		 9893 case EM_OPENRISC:
9894 case EM_OR32:
9895 return reloc_type == 1; /* R_OR32_32. */
aca88567 9896 case EM_PARISC:
5fda8eca
NC		 9897 return (reloc_type == 1 /* R_PARISC_DIR32. */
9898 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 9899 case EM_PJ:
9900 case EM_PJ_OLD:
9901 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9902 case EM_PPC64:
9903 return reloc_type == 1; /* R_PPC64_ADDR32. */
9904 case EM_PPC:
9905 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 9906 case EM_RL78:
9907 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 9908 case EM_RX:
9909 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 9910 case EM_S370:
9911 return reloc_type == 1; /* R_I370_ADDR31. */
9912 case EM_S390_OLD:
9913 case EM_S390:
9914 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 9915 case EM_SCORE:
9916 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 9917 case EM_SH:
9918 return reloc_type == 1; /* R_SH_DIR32. */
9919 case EM_SPARC32PLUS:
9920 case EM_SPARCV9:
9921 case EM_SPARC:
9922 return reloc_type == 3 /* R_SPARC_32. */
9923 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 9924 case EM_SPU:
9925 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 9926 case EM_TI_C6000:
9927 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 9928 case EM_TILEGX:
9929 return reloc_type == 2; /* R_TILEGX_32. */
9930 case EM_TILEPRO:
9931 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 9932 case EM_CYGNUS_V850:
9933 case EM_V850:
9934 return reloc_type == 6; /* R_V850_ABS32. */
9935 case EM_VAX:
9936 return reloc_type == 1; /* R_VAX_32. */
9937 case EM_X86_64:
8a9036a4 9938 case EM_L1OM:
7a9068fe 9939 case EM_K1OM:
aca88567 9940 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 9941 case EM_XC16X:
9942 case EM_C166:
9943 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 9944 case EM_XGATE:
9945 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 9946 case EM_XSTORMY16:
9947 return reloc_type == 1; /* R_XSTROMY16_32. */
9948 case EM_XTENSA_OLD:
9949 case EM_XTENSA:
9950 return reloc_type == 1; /* R_XTENSA_32. */
aca88567
NC		 9951 default:
9952 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9953 elf_header.e_machine);
9954 abort ();
9955 }
9956}
9957
9958/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9959 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9960
9961static bfd_boolean
9962is_32bit_pcrel_reloc (unsigned int reloc_type)
9963{
9964 switch (elf_header.e_machine)
9965 {
41e92641
NC		 9966 case EM_386:
9967 case EM_486:
3e0873ac 9968 return reloc_type == 2; /* R_386_PC32. */
aca88567 9969 case EM_68K:
3e0873ac 9970 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 9971 case EM_AARCH64:
9972 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 9973 case EM_ADAPTEVA_EPIPHANY:
9974 return reloc_type == 6;
aca88567
NC		 9975 case EM_ALPHA:
9976 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 9977 case EM_ARM:
3e0873ac 9978 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 9979 case EM_MICROBLAZE:
9980 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
aca88567 9981 case EM_PARISC:
85acf597 9982 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 9983 case EM_PPC:
9984 return reloc_type == 26; /* R_PPC_REL32. */
9985 case EM_PPC64:
3e0873ac 9986 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 9987 case EM_S390_OLD:
9988 case EM_S390:
3e0873ac 9989 return reloc_type == 5; /* R_390_PC32. */
aca88567 9990 case EM_SH:
3e0873ac 9991 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 9992 case EM_SPARC32PLUS:
9993 case EM_SPARCV9:
9994 case EM_SPARC:
3e0873ac 9995 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 9996 case EM_SPU:
9997 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 9998 case EM_TILEGX:
9999 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10000 case EM_TILEPRO:
10001 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
aca88567 10002 case EM_X86_64:
8a9036a4 10003 case EM_L1OM:
7a9068fe 10004 case EM_K1OM:
3e0873ac 10005 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 10006 case EM_XTENSA_OLD:
10007 case EM_XTENSA:
10008 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 10009 default:
10010 /* Do not abort or issue an error message here. Not all targets use
10011 pc-relative 32-bit relocs in their DWARF debug information and we
10012 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 10013 more helpful warning message will be generated by apply_relocations
10014 anyway, so just return. */
aca88567
NC		 10015 return FALSE;
10016 }
10017}
10018
10019/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10020 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10021
10022static bfd_boolean
10023is_64bit_abs_reloc (unsigned int reloc_type)
10024{
10025 switch (elf_header.e_machine)
10026 {
a06ea964
NC		 10027 case EM_AARCH64:
10028 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 10029 case EM_ALPHA:
10030 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 10031 case EM_IA_64:
10032 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 10033 case EM_PARISC:
10034 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 10035 case EM_PPC64:
10036 return reloc_type == 38; /* R_PPC64_ADDR64. */
10037 case EM_SPARC32PLUS:
10038 case EM_SPARCV9:
10039 case EM_SPARC:
10040 return reloc_type == 54; /* R_SPARC_UA64. */
10041 case EM_X86_64:
8a9036a4 10042 case EM_L1OM:
7a9068fe 10043 case EM_K1OM:
aca88567 10044 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 10045 case EM_S390_OLD:
10046 case EM_S390:
aa137e4d
NC		 10047 return reloc_type == 22; /* R_S390_64. */
10048 case EM_TILEGX:
10049 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 10050 case EM_MIPS:
aa137e4d 10051 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 10052 default:
10053 return FALSE;
10054 }
10055}
10056
85acf597
RH		 10057/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10058 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10059
10060static bfd_boolean
10061is_64bit_pcrel_reloc (unsigned int reloc_type)
10062{
10063 switch (elf_header.e_machine)
10064 {
a06ea964
NC		 10065 case EM_AARCH64:
10066 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 10067 case EM_ALPHA:
aa137e4d 10068 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 10069 case EM_IA_64:
aa137e4d 10070 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 10071 case EM_PARISC:
aa137e4d 10072 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 10073 case EM_PPC64:
aa137e4d 10074 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 10075 case EM_SPARC32PLUS:
10076 case EM_SPARCV9:
10077 case EM_SPARC:
aa137e4d 10078 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 10079 case EM_X86_64:
8a9036a4 10080 case EM_L1OM:
7a9068fe 10081 case EM_K1OM:
aa137e4d 10082 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 10083 case EM_S390_OLD:
10084 case EM_S390:
aa137e4d
NC		 10085 return reloc_type == 23; /* R_S390_PC64. */
10086 case EM_TILEGX:
10087 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 10088 default:
10089 return FALSE;
10090 }
10091}
10092
4dc3c23d
AM		 10093/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10094 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10095
10096static bfd_boolean
10097is_24bit_abs_reloc (unsigned int reloc_type)
10098{
10099 switch (elf_header.e_machine)
10100 {
10101 case EM_CYGNUS_MN10200:
10102 case EM_MN10200:
10103 return reloc_type == 4; /* R_MN10200_24. */
10104 default:
10105 return FALSE;
10106 }
10107}
10108
aca88567
NC		 10109/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10110 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10111
10112static bfd_boolean
10113is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 10114{
10115 switch (elf_header.e_machine)
10116 {
aca88567
NC		 10117 case EM_AVR_OLD:
10118 case EM_AVR:
10119 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 10120 case EM_ADAPTEVA_EPIPHANY:
10121 return reloc_type == 5;
41e92641
NC		 10122 case EM_CYGNUS_D10V:
10123 case EM_D10V:
10124 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 10125 case EM_H8S:
10126 case EM_H8_300:
10127 case EM_H8_300H:
aca88567
NC		 10128 return reloc_type == R_H8_DIR16;
10129 case EM_IP2K_OLD:
10130 case EM_IP2K:
10131 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 10132 case EM_M32C_OLD:
f4236fe4
DD		 10133 case EM_M32C:
10134 return reloc_type == 1; /* R_M32C_16 */
aca88567
NC		 10135 case EM_MSP430_OLD:
10136 case EM_MSP430:
10137 return reloc_type == 5; /* R_MSP430_16_BYTE. */
3e0873ac
NC		 10138 case EM_ALTERA_NIOS2:
10139 case EM_NIOS32:
10140 return reloc_type == 9; /* R_NIOS_16. */
40b36596
JM		 10141 case EM_TI_C6000:
10142 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 10143 case EM_XC16X:
10144 case EM_C166:
10145 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 10146 case EM_CYGNUS_MN10200:
10147 case EM_MN10200:
10148 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 10149 case EM_CYGNUS_MN10300:
10150 case EM_MN10300:
10151 return reloc_type == 2; /* R_MN10300_16. */
f6c1a2d5
NC		 10152 case EM_XGATE:
10153 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 10154 default:
aca88567 10155 return FALSE;
4b78141a
NC		 10156 }
10157}
10158
2a7b2e88
JK		 10159/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10160 relocation entries (possibly formerly used for SHT_GROUP sections). */
10161
10162static bfd_boolean
10163is_none_reloc (unsigned int reloc_type)
10164{
10165 switch (elf_header.e_machine)
10166 {
cb8f3167
NC		 10167 case EM_68K: /* R_68K_NONE. */
10168 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 10169 case EM_SPARC32PLUS:
10170 case EM_SPARCV9:
cb8f3167
NC		 10171 case EM_SPARC: /* R_SPARC_NONE. */
10172 case EM_MIPS: /* R_MIPS_NONE. */
10173 case EM_PARISC: /* R_PARISC_NONE. */
10174 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 10175 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 10176 case EM_PPC: /* R_PPC_NONE. */
10177 case EM_PPC64: /* R_PPC64_NONE. */
10178 case EM_ARM: /* R_ARM_NONE. */
10179 case EM_IA_64: /* R_IA64_NONE. */
10180 case EM_SH: /* R_SH_NONE. */
2a7b2e88 10181 case EM_S390_OLD:
cb8f3167
NC		 10182 case EM_S390: /* R_390_NONE. */
10183 case EM_CRIS: /* R_CRIS_NONE. */
10184 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 10185 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 10186 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 10187 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 10188 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 10189 case EM_M32R: /* R_M32R_NONE. */
40b36596 10190 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 10191 case EM_TILEGX: /* R_TILEGX_NONE. */
10192 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 10193 case EM_XC16X:
10194 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 10195 return reloc_type == 0;
a06ea964
NC		 10196 case EM_AARCH64:
10197 return reloc_type == 0 || reloc_type == 256;
58332dda
JK		 10198 case EM_XTENSA_OLD:
10199 case EM_XTENSA:
4dc3c23d
AM		 10200 return (reloc_type == 0 /* R_XTENSA_NONE. */
10201 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10202 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10203 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 10204 }
10205 return FALSE;
10206}
10207
cf13d699
NC		 10208/* Apply relocations to a section.
10209 Note: So far support has been added only for those relocations
10210 which can be found in debug sections.
10211 FIXME: Add support for more relocations ? */
1b315056 10212
cf13d699
NC		 10213static void
10214apply_relocations (void * file,
10215 Elf_Internal_Shdr * section,
10216 unsigned char * start)
1b315056 10217{
cf13d699
NC		 10218 Elf_Internal_Shdr * relsec;
10219 unsigned char * end = start + section->sh_size;
cb8f3167 10220
cf13d699
NC		 10221 if (elf_header.e_type != ET_REL)
10222 return;
1b315056 10223
cf13d699 10224 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 10225 for (relsec = section_headers;
10226 relsec < section_headers + elf_header.e_shnum;
10227 ++relsec)
252b5132 10228 {
41e92641
NC		 10229 bfd_boolean is_rela;
10230 unsigned long num_relocs;
2cf0635d
NC		 10231 Elf_Internal_Rela * relocs;
10232 Elf_Internal_Rela * rp;
10233 Elf_Internal_Shdr * symsec;
10234 Elf_Internal_Sym * symtab;
ba5cdace 10235 unsigned long num_syms;
2cf0635d 10236 Elf_Internal_Sym * sym;
252b5132 10237
41e92641 10238 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 10239 || relsec->sh_info >= elf_header.e_shnum
10240 || section_headers + relsec->sh_info != section
c256ffe7 10241 || relsec->sh_size == 0
4fbb74a6 10242 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 10243 continue;
428409d5 10244
41e92641
NC		 10245 is_rela = relsec->sh_type == SHT_RELA;
10246
10247 if (is_rela)
10248 {
3f5e193b
NC		 10249 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10250 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10251 return;
10252 }
10253 else
10254 {
3f5e193b
NC		 10255 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10256 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 10257 return;
10258 }
10259
10260 /* SH uses RELA but uses in place value instead of the addend field. */
10261 if (elf_header.e_machine == EM_SH)
10262 is_rela = FALSE;
428409d5 10263
4fbb74a6 10264 symsec = section_headers + relsec->sh_link;
ba5cdace 10265 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 10266
41e92641 10267 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 10268 {
41e92641
NC		 10269 bfd_vma addend;
10270 unsigned int reloc_type;
10271 unsigned int reloc_size;
91d6fa6a 10272 unsigned char * rloc;
ba5cdace 10273 unsigned long sym_index;
4b78141a 10274
aca88567 10275 reloc_type = get_reloc_type (rp->r_info);
41e92641 10276
98fb390a 10277 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 10278 continue;
98fb390a
NC		 10279 else if (is_none_reloc (reloc_type))
10280 continue;
10281 else if (is_32bit_abs_reloc (reloc_type)
10282 || is_32bit_pcrel_reloc (reloc_type))
aca88567 10283 reloc_size = 4;
85acf597
RH		 10284 else if (is_64bit_abs_reloc (reloc_type)
10285 || is_64bit_pcrel_reloc (reloc_type))
aca88567 10286 reloc_size = 8;
4dc3c23d
AM		 10287 else if (is_24bit_abs_reloc (reloc_type))
10288 reloc_size = 3;
aca88567
NC		 10289 else if (is_16bit_abs_reloc (reloc_type))
10290 reloc_size = 2;
10291 else
4b78141a 10292 {
41e92641 10293 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
aca88567 10294 reloc_type, SECTION_NAME (section));
4b78141a
NC		 10295 continue;
10296 }
103f02d3 10297
91d6fa6a
NC		 10298 rloc = start + rp->r_offset;
10299 if ((rloc + reloc_size) > end)
700dd8b7
L		 10300 {
10301 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10302 (unsigned long) rp->r_offset,
10303 SECTION_NAME (section));
10304 continue;
10305 }
103f02d3 10306
ba5cdace
NC		 10307 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10308 if (sym_index >= num_syms)
10309 {
10310 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10311 sym_index, SECTION_NAME (section));
10312 continue;
10313 }
10314 sym = symtab + sym_index;
41e92641
NC		 10315
10316 /* If the reloc has a symbol associated with it,
55f25fc3
L		 10317 make sure that it is of an appropriate type.
10318
10319 Relocations against symbols without type can happen.
10320 Gcc -feliminate-dwarf2-dups may generate symbols
10321 without type for debug info.
10322
10323 Icc generates relocations against function symbols
10324 instead of local labels.
10325
10326 Relocations against object symbols can happen, eg when
10327 referencing a global array. For an example of this see
10328 the _clz.o binary in libgcc.a. */
aca88567 10329 if (sym != symtab
55f25fc3 10330 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 10331 {
41e92641 10332 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 10333 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 10334 (long int)(rp - relocs),
41e92641 10335 SECTION_NAME (relsec));
aca88567 10336 continue;
5b18a4bc 10337 }
252b5132 10338
4dc3c23d
AM		 10339 addend = 0;
10340 if (is_rela)
10341 addend += rp->r_addend;
c47320c3
AM		 10342 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10343 partial_inplace. */
4dc3c23d
AM		 10344 if (!is_rela
10345 || (elf_header.e_machine == EM_XTENSA
10346 && reloc_type == 1)
10347 || ((elf_header.e_machine == EM_PJ
10348 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 10349 && reloc_type == 1)
10350 || ((elf_header.e_machine == EM_D30V
10351 || elf_header.e_machine == EM_CYGNUS_D30V)
10352 && reloc_type == 12))
91d6fa6a 10353 addend += byte_get (rloc, reloc_size);
cb8f3167 10354
85acf597
RH		 10355 if (is_32bit_pcrel_reloc (reloc_type)
10356 || is_64bit_pcrel_reloc (reloc_type))
10357 {
10358 /* On HPPA, all pc-relative relocations are biased by 8. */
10359 if (elf_header.e_machine == EM_PARISC)
10360 addend -= 8;
91d6fa6a 10361 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 10362 reloc_size);
10363 }
41e92641 10364 else
91d6fa6a 10365 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 10366 }
252b5132 10367
5b18a4bc 10368 free (symtab);
41e92641 10369 free (relocs);
5b18a4bc
NC		 10370 break;
10371 }
5b18a4bc 10372}
103f02d3 10373
cf13d699
NC		 10374#ifdef SUPPORT_DISASSEMBLY
10375static int
10376disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10377{
10378 printf (_("\nAssembly dump of section %s\n"),
10379 SECTION_NAME (section));
10380
10381 /* XXX -- to be done --- XXX */
10382
10383 return 1;
10384}
10385#endif
10386
10387/* Reads in the contents of SECTION from FILE, returning a pointer
10388 to a malloc'ed buffer or NULL if something went wrong. */
10389
10390static char *
10391get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10392{
10393 bfd_size_type num_bytes;
10394
10395 num_bytes = section->sh_size;
10396
10397 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10398 {
10399 printf (_("\nSection '%s' has no data to dump.\n"),
10400 SECTION_NAME (section));
10401 return NULL;
10402 }
10403
3f5e193b
NC		 10404 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10405 _("section contents"));
cf13d699
NC		 10406}
10407
dd24e3da 10408
cf13d699
NC		 10409static void
10410dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10411{
10412 Elf_Internal_Shdr * relsec;
10413 bfd_size_type num_bytes;
cf13d699
NC		 10414 char * data;
10415 char * end;
10416 char * start;
10417 char * name = SECTION_NAME (section);
10418 bfd_boolean some_strings_shown;
10419
10420 start = get_section_contents (section, file);
10421 if (start == NULL)
10422 return;
10423
10424 printf (_("\nString dump of section '%s':\n"), name);
10425
10426 /* If the section being dumped has relocations against it the user might
10427 be expecting these relocations to have been applied. Check for this
10428 case and issue a warning message in order to avoid confusion.
10429 FIXME: Maybe we ought to have an option that dumps a section with
10430 relocs applied ? */
10431 for (relsec = section_headers;
10432 relsec < section_headers + elf_header.e_shnum;
10433 ++relsec)
10434 {
10435 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10436 || relsec->sh_info >= elf_header.e_shnum
10437 || section_headers + relsec->sh_info != section
10438 || relsec->sh_size == 0
10439 || relsec->sh_link >= elf_header.e_shnum)
10440 continue;
10441
10442 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10443 break;
10444 }
10445
10446 num_bytes = section->sh_size;
cf13d699
NC		 10447 data = start;
10448 end = start + num_bytes;
10449 some_strings_shown = FALSE;
10450
10451 while (data < end)
10452 {
10453 while (!ISPRINT (* data))
10454 if (++ data >= end)
10455 break;
10456
10457 if (data < end)
10458 {
10459#ifndef __MSVCRT__
c975cc98
NC		 10460 /* PR 11128: Use two separate invocations in order to work
10461 around bugs in the Solaris 8 implementation of printf. */
10462 printf (" [%6tx] ", data - start);
10463 printf ("%s\n", data);
cf13d699
NC		 10464#else
10465 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10466#endif
10467 data += strlen (data);
10468 some_strings_shown = TRUE;
10469 }
10470 }
10471
10472 if (! some_strings_shown)
10473 printf (_(" No strings found in this section."));
10474
10475 free (start);
10476
10477 putchar ('\n');
10478}
10479
10480static void
10481dump_section_as_bytes (Elf_Internal_Shdr * section,
10482 FILE * file,
10483 bfd_boolean relocate)
10484{
10485 Elf_Internal_Shdr * relsec;
10486 bfd_size_type bytes;
10487 bfd_vma addr;
10488 unsigned char * data;
10489 unsigned char * start;
10490
10491 start = (unsigned char *) get_section_contents (section, file);
10492 if (start == NULL)
10493 return;
10494
10495 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10496
10497 if (relocate)
10498 {
10499 apply_relocations (file, section, start);
10500 }
10501 else
10502 {
10503 /* If the section being dumped has relocations against it the user might
10504 be expecting these relocations to have been applied. Check for this
10505 case and issue a warning message in order to avoid confusion.
10506 FIXME: Maybe we ought to have an option that dumps a section with
10507 relocs applied ? */
10508 for (relsec = section_headers;
10509 relsec < section_headers + elf_header.e_shnum;
10510 ++relsec)
10511 {
10512 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10513 || relsec->sh_info >= elf_header.e_shnum
10514 || section_headers + relsec->sh_info != section
10515 || relsec->sh_size == 0
10516 || relsec->sh_link >= elf_header.e_shnum)
10517 continue;
10518
10519 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10520 break;
10521 }
10522 }
10523
10524 addr = section->sh_addr;
10525 bytes = section->sh_size;
10526 data = start;
10527
10528 while (bytes)
10529 {
10530 int j;
10531 int k;
10532 int lbytes;
10533
10534 lbytes = (bytes > 16 ? 16 : bytes);
10535
10536 printf (" 0x%8.8lx ", (unsigned long) addr);
10537
10538 for (j = 0; j < 16; j++)
10539 {
10540 if (j < lbytes)
10541 printf ("%2.2x", data[j]);
10542 else
10543 printf (" ");
10544
10545 if ((j & 3) == 3)
10546 printf (" ");
10547 }
10548
10549 for (j = 0; j < lbytes; j++)
10550 {
10551 k = data[j];
10552 if (k >= ' ' && k < 0x7f)
10553 printf ("%c", k);
10554 else
10555 printf (".");
10556 }
10557
10558 putchar ('\n');
10559
10560 data += lbytes;
10561 addr += lbytes;
10562 bytes -= lbytes;
10563 }
10564
10565 free (start);
10566
10567 putchar ('\n');
10568}
10569
4a114e3e 10570/* Uncompresses a section that was compressed using zlib, in place. */
cf13d699
NC		 10571
10572static int
d3dbc530
AM		 10573uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10574 dwarf_size_type *size ATTRIBUTE_UNUSED)
cf13d699
NC		 10575{
10576#ifndef HAVE_ZLIB_H
cf13d699
NC		 10577 return FALSE;
10578#else
10579 dwarf_size_type compressed_size = *size;
10580 unsigned char * compressed_buffer = *buffer;
10581 dwarf_size_type uncompressed_size;
10582 unsigned char * uncompressed_buffer;
10583 z_stream strm;
10584 int rc;
10585 dwarf_size_type header_size = 12;
10586
10587 /* Read the zlib header. In this case, it should be "ZLIB" followed
10588 by the uncompressed section size, 8 bytes in big-endian order. */
10589 if (compressed_size < header_size
10590 || ! streq ((char *) compressed_buffer, "ZLIB"))
10591 return 0;
10592
10593 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10594 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10595 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10596 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10597 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10598 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10599 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10600 uncompressed_size += compressed_buffer[11];
10601
10602 /* It is possible the section consists of several compressed
10603 buffers concatenated together, so we uncompress in a loop. */
10604 strm.zalloc = NULL;
10605 strm.zfree = NULL;
10606 strm.opaque = NULL;
10607 strm.avail_in = compressed_size - header_size;
10608 strm.next_in = (Bytef *) compressed_buffer + header_size;
10609 strm.avail_out = uncompressed_size;
3f5e193b 10610 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
cf13d699
NC		 10611
10612 rc = inflateInit (& strm);
10613 while (strm.avail_in > 0)
10614 {
10615 if (rc != Z_OK)
10616 goto fail;
10617 strm.next_out = ((Bytef *) uncompressed_buffer
10618 + (uncompressed_size - strm.avail_out));
10619 rc = inflate (&strm, Z_FINISH);
10620 if (rc != Z_STREAM_END)
10621 goto fail;
10622 rc = inflateReset (& strm);
10623 }
10624 rc = inflateEnd (& strm);
10625 if (rc != Z_OK
10626 || strm.avail_out != 0)
10627 goto fail;
10628
10629 free (compressed_buffer);
10630 *buffer = uncompressed_buffer;
10631 *size = uncompressed_size;
10632 return 1;
10633
10634 fail:
10635 free (uncompressed_buffer);
4a114e3e
L		 10636 /* Indicate decompression failure. */
10637 *buffer = NULL;
cf13d699
NC		 10638 return 0;
10639#endif /* HAVE_ZLIB_H */
10640}
10641
d966045b
DJ		 10642static int
10643load_specific_debug_section (enum dwarf_section_display_enum debug,
2cf0635d 10644 Elf_Internal_Shdr * sec, void * file)
1007acb3 10645{
2cf0635d 10646 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 10647 char buf [64];
1007acb3 10648
19e6b90e
L		 10649 /* If it is already loaded, do nothing. */
10650 if (section->start != NULL)
10651 return 1;
1007acb3 10652
19e6b90e
L		 10653 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10654 section->address = sec->sh_addr;
3f5e193b
NC		 10655 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10656 sec->sh_offset, 1,
10657 sec->sh_size, buf);
59245841
NC		 10658 if (section->start == NULL)
10659 section->size = 0;
10660 else
10661 {
10662 section->size = sec->sh_size;
10663 if (uncompress_section_contents (&section->start, &section->size))
10664 sec->sh_size = section->size;
10665 }
4a114e3e 10666
1b315056
CS		 10667 if (section->start == NULL)
10668 return 0;
10669
19e6b90e 10670 if (debug_displays [debug].relocate)
3f5e193b 10671 apply_relocations ((FILE *) file, sec, section->start);
1007acb3 10672
1b315056 10673 return 1;
1007acb3
L		 10674}
10675
d966045b 10676int
2cf0635d 10677load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 10678{
2cf0635d
NC		 10679 struct dwarf_section * section = &debug_displays [debug].section;
10680 Elf_Internal_Shdr * sec;
d966045b
DJ		 10681
10682 /* Locate the debug section. */
10683 sec = find_section (section->uncompressed_name);
10684 if (sec != NULL)
10685 section->name = section->uncompressed_name;
10686 else
10687 {
10688 sec = find_section (section->compressed_name);
10689 if (sec != NULL)
10690 section->name = section->compressed_name;
10691 }
10692 if (sec == NULL)
10693 return 0;
10694
3f5e193b 10695 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 10696}
10697
19e6b90e
L		 10698void
10699free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 10700{
2cf0635d 10701 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 10702
19e6b90e
L		 10703 if (section->start == NULL)
10704 return;
1007acb3 10705
19e6b90e
L		 10706 free ((char *) section->start);
10707 section->start = NULL;
10708 section->address = 0;
10709 section->size = 0;
1007acb3
L		 10710}
10711
1007acb3 10712static int
2cf0635d 10713display_debug_section (Elf_Internal_Shdr * section, FILE * file)
1007acb3 10714{
2cf0635d 10715 char * name = SECTION_NAME (section);
19e6b90e
L		 10716 bfd_size_type length;
10717 int result = 1;
3f5e193b 10718 int i;
1007acb3 10719
19e6b90e
L		 10720 length = section->sh_size;
10721 if (length == 0)
1007acb3 10722 {
19e6b90e
L		 10723 printf (_("\nSection '%s' has no debugging data.\n"), name);
10724 return 0;
1007acb3 10725 }
5dff79d8
NC		 10726 if (section->sh_type == SHT_NOBITS)
10727 {
10728 /* There is no point in dumping the contents of a debugging section
10729 which has the NOBITS type - the bits in the file will be random.
10730 This can happen when a file containing a .eh_frame section is
10731 stripped with the --only-keep-debug command line option. */
10732 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10733 return 0;
10734 }
1007acb3 10735
0112cd26 10736 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 10737 name = ".debug_info";
1007acb3 10738
19e6b90e
L		 10739 /* See if we know how to display the contents of this section. */
10740 for (i = 0; i < max; i++)
1b315056
CS		 10741 if (streq (debug_displays[i].section.uncompressed_name, name)
10742 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 10743 {
2cf0635d 10744 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 10745 int secondary = (section != find_section (name));
10746
10747 if (secondary)
3f5e193b 10748 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 10749
2b6f5997 10750 if (streq (sec->uncompressed_name, name))
d966045b
DJ		 10751 sec->name = sec->uncompressed_name;
10752 else
10753 sec->name = sec->compressed_name;
3f5e193b
NC		 10754 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10755 section, file))
19e6b90e
L		 10756 {
10757 result &= debug_displays[i].display (sec, file);
1007acb3 10758
d966045b 10759 if (secondary || (i != info && i != abbrev))
3f5e193b 10760 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 10761 }
1007acb3 10762
19e6b90e
L		 10763 break;
10764 }
1007acb3 10765
19e6b90e 10766 if (i == max)
1007acb3 10767 {
19e6b90e
L		 10768 printf (_("Unrecognized debug section: %s\n"), name);
10769 result = 0;
1007acb3
L		 10770 }
10771
19e6b90e 10772 return result;
5b18a4bc 10773}
103f02d3 10774
aef1f6d0
DJ		 10775/* Set DUMP_SECTS for all sections where dumps were requested
10776 based on section name. */
10777
10778static void
10779initialise_dumps_byname (void)
10780{
2cf0635d 10781 struct dump_list_entry * cur;
aef1f6d0
DJ		 10782
10783 for (cur = dump_sects_byname; cur; cur = cur->next)
10784 {
10785 unsigned int i;
10786 int any;
10787
10788 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10789 if (streq (SECTION_NAME (section_headers + i), cur->name))
10790 {
09c11c86 10791 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 10792 any = 1;
10793 }
10794
10795 if (!any)
10796 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10797 cur->name);
10798 }
10799}
10800
5b18a4bc 10801static void
2cf0635d 10802process_section_contents (FILE * file)
5b18a4bc 10803{
2cf0635d 10804 Elf_Internal_Shdr * section;
19e6b90e 10805 unsigned int i;
103f02d3 10806
19e6b90e
L		 10807 if (! do_dump)
10808 return;
103f02d3 10809
aef1f6d0
DJ		 10810 initialise_dumps_byname ();
10811
19e6b90e
L		 10812 for (i = 0, section = section_headers;
10813 i < elf_header.e_shnum && i < num_dump_sects;
10814 i++, section++)
10815 {
10816#ifdef SUPPORT_DISASSEMBLY
10817 if (dump_sects[i] & DISASS_DUMP)
10818 disassemble_section (section, file);
10819#endif
10820 if (dump_sects[i] & HEX_DUMP)
cf13d699 10821 dump_section_as_bytes (section, file, FALSE);
103f02d3 10822
cf13d699
NC		 10823 if (dump_sects[i] & RELOC_DUMP)
10824 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 10825
10826 if (dump_sects[i] & STRING_DUMP)
10827 dump_section_as_strings (section, file);
cf13d699
NC		 10828
10829 if (dump_sects[i] & DEBUG_DUMP)
10830 display_debug_section (section, file);
5b18a4bc 10831 }
103f02d3 10832
19e6b90e
L		 10833 /* Check to see if the user requested a
10834 dump of a section that does not exist. */
10835 while (i++ < num_dump_sects)
10836 if (dump_sects[i])
10837 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 10838}
103f02d3 10839
5b18a4bc 10840static void
19e6b90e 10841process_mips_fpe_exception (int mask)
5b18a4bc 10842{
19e6b90e
L		 10843 if (mask)
10844 {
10845 int first = 1;
10846 if (mask & OEX_FPU_INEX)
10847 fputs ("INEX", stdout), first = 0;
10848 if (mask & OEX_FPU_UFLO)
10849 printf ("%sUFLO", first ? "" : "|"), first = 0;
10850 if (mask & OEX_FPU_OFLO)
10851 printf ("%sOFLO", first ? "" : "|"), first = 0;
10852 if (mask & OEX_FPU_DIV0)
10853 printf ("%sDIV0", first ? "" : "|"), first = 0;
10854 if (mask & OEX_FPU_INVAL)
10855 printf ("%sINVAL", first ? "" : "|");
10856 }
5b18a4bc 10857 else
19e6b90e 10858 fputs ("0", stdout);
5b18a4bc 10859}
103f02d3 10860
11c1ff18
PB		 10861/* ARM EABI attributes section. */
10862typedef struct
10863{
10864 int tag;
2cf0635d 10865 const char * name;
11c1ff18
PB		 10866 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10867 int type;
2cf0635d 10868 const char ** table;
11c1ff18
PB		 10869} arm_attr_public_tag;
10870
2cf0635d 10871static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 10872 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 10873 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 10874static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10875static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 10876 {"No", "Thumb-1", "Thumb-2"};
75375b3e 10877static const char * arm_attr_tag_FP_arch[] =
bca38921
MGD		 10878 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
10879 "FP for ARMv8"};
2cf0635d 10880static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 10881static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 10882 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 10883static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 10884 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10885 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 10886static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 10887 {"V6", "SB", "TLS", "Unused"};
2cf0635d 10888static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 10889 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 10890static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 10891 {"Absolute", "PC-relative", "None"};
2cf0635d 10892static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 10893 {"None", "direct", "GOT-indirect"};
2cf0635d 10894static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 10895 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 10896static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10897static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 10898 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 10899static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10900static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10901static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 10902 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 10903static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 10904 {"Unused", "small", "int", "forced to int"};
2cf0635d 10905static const char * arm_attr_tag_ABI_HardFP_use[] =
75375b3e 10906 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
2cf0635d 10907static const char * arm_attr_tag_ABI_VFP_args[] =
11c1ff18 10908 {"AAPCS", "VFP registers", "custom"};
2cf0635d 10909static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 10910 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 10911static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 10912 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10913 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 10914static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 10915 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10916 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 10917static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 10918static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 10919 {"Not Allowed", "Allowed"};
2cf0635d 10920static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 10921 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 10922static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 10923 {"Not Allowed", "Allowed"};
10924static const char * arm_attr_tag_DIV_use[] =
dd24e3da 10925 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 10926 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 10927static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10928static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 10929 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 10930 "TrustZone and Virtualization Extensions"};
dd24e3da 10931static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 10932 {"Not Allowed", "Allowed"};
11c1ff18
PB		 10933
10934#define LOOKUP(id, name) \
10935 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 10936static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 10937{
10938 {4, "CPU_raw_name", 1, NULL},
10939 {5, "CPU_name", 1, NULL},
10940 LOOKUP(6, CPU_arch),
10941 {7, "CPU_arch_profile", 0, NULL},
10942 LOOKUP(8, ARM_ISA_use),
10943 LOOKUP(9, THUMB_ISA_use),
75375b3e 10944 LOOKUP(10, FP_arch),
11c1ff18 10945 LOOKUP(11, WMMX_arch),
f5f53991
AS		 10946 LOOKUP(12, Advanced_SIMD_arch),
10947 LOOKUP(13, PCS_config),
11c1ff18
PB		 10948 LOOKUP(14, ABI_PCS_R9_use),
10949 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 10950 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 10951 LOOKUP(17, ABI_PCS_GOT_use),
10952 LOOKUP(18, ABI_PCS_wchar_t),
10953 LOOKUP(19, ABI_FP_rounding),
10954 LOOKUP(20, ABI_FP_denormal),
10955 LOOKUP(21, ABI_FP_exceptions),
10956 LOOKUP(22, ABI_FP_user_exceptions),
10957 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 10958 {24, "ABI_align_needed", 0, NULL},
10959 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 10960 LOOKUP(26, ABI_enum_size),
10961 LOOKUP(27, ABI_HardFP_use),
10962 LOOKUP(28, ABI_VFP_args),
10963 LOOKUP(29, ABI_WMMX_args),
10964 LOOKUP(30, ABI_optimization_goals),
10965 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 10966 {32, "compatibility", 0, NULL},
f5f53991 10967 LOOKUP(34, CPU_unaligned_access),
75375b3e 10968 LOOKUP(36, FP_HP_extension),
8e79c3df 10969 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 10970 LOOKUP(42, MPextension_use),
10971 LOOKUP(44, DIV_use),
f5f53991
AS		 10972 {64, "nodefaults", 0, NULL},
10973 {65, "also_compatible_with", 0, NULL},
10974 LOOKUP(66, T2EE_use),
10975 {67, "conformance", 1, NULL},
10976 LOOKUP(68, Virtualization_use),
cd21e546 10977 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 10978};
10979#undef LOOKUP
10980
11c1ff18 10981static unsigned char *
2cf0635d 10982display_arm_attribute (unsigned char * p)
11c1ff18
PB		 10983{
10984 int tag;
10985 unsigned int len;
10986 int val;
2cf0635d 10987 arm_attr_public_tag * attr;
11c1ff18
PB		 10988 unsigned i;
10989 int type;
10990
10991 tag = read_uleb128 (p, &len);
10992 p += len;
10993 attr = NULL;
2cf0635d 10994 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 10995 {
10996 if (arm_attr_public_tags[i].tag == tag)
10997 {
10998 attr = &arm_attr_public_tags[i];
10999 break;
11000 }
11001 }
11002
11003 if (attr)
11004 {
11005 printf (" Tag_%s: ", attr->name);
11006 switch (attr->type)
11007 {
11008 case 0:
11009 switch (tag)
11010 {
11011 case 7: /* Tag_CPU_arch_profile. */
11012 val = read_uleb128 (p, &len);
11013 p += len;
11014 switch (val)
11015 {
2b692964
NC		 11016 case 0: printf (_("None\n")); break;
11017 case 'A': printf (_("Application\n")); break;
11018 case 'R': printf (_("Realtime\n")); break;
11019 case 'M': printf (_("Microcontroller\n")); break;
11020 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 11021 default: printf ("??? (%d)\n", val); break;
11022 }
11023 break;
11024
75375b3e
MGD		 11025 case 24: /* Tag_align_needed. */
11026 val = read_uleb128 (p, &len);
11027 p += len;
11028 switch (val)
11029 {
2b692964
NC		 11030 case 0: printf (_("None\n")); break;
11031 case 1: printf (_("8-byte\n")); break;
11032 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 11033 case 3: printf ("??? 3\n"); break;
11034 default:
11035 if (val <= 12)
dd24e3da 11036 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11037 1 << val);
11038 else
11039 printf ("??? (%d)\n", val);
11040 break;
11041 }
11042 break;
11043
11044 case 25: /* Tag_align_preserved. */
11045 val = read_uleb128 (p, &len);
11046 p += len;
11047 switch (val)
11048 {
2b692964
NC		 11049 case 0: printf (_("None\n")); break;
11050 case 1: printf (_("8-byte, except leaf SP\n")); break;
11051 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 11052 case 3: printf ("??? 3\n"); break;
11053 default:
11054 if (val <= 12)
dd24e3da 11055 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 11056 1 << val);
11057 else
11058 printf ("??? (%d)\n", val);
11059 break;
11060 }
11061 break;
11062
11c1ff18
PB		 11063 case 32: /* Tag_compatibility. */
11064 val = read_uleb128 (p, &len);
11065 p += len;
2b692964 11066 printf (_("flag = %d, vendor = %s\n"), val, p);
2cf0635d 11067 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11068 break;
11069
f5f53991
AS		 11070 case 64: /* Tag_nodefaults. */
11071 p++;
2b692964 11072 printf (_("True\n"));
f5f53991
AS		 11073 break;
11074
11075 case 65: /* Tag_also_compatible_with. */
11076 val = read_uleb128 (p, &len);
11077 p += len;
11078 if (val == 6 /* Tag_CPU_arch. */)
11079 {
11080 val = read_uleb128 (p, &len);
11081 p += len;
2cf0635d 11082 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 11083 printf ("??? (%d)\n", val);
11084 else
11085 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11086 }
11087 else
11088 printf ("???\n");
11089 while (*(p++) != '\0' /* NUL terminator. */);
11090 break;
11091
11c1ff18 11092 default:
2cf0635d 11093 abort ();
11c1ff18
PB		 11094 }
11095 return p;
11096
11097 case 1:
11098 case 2:
11099 type = attr->type;
11100 break;
11101
11102 default:
11103 assert (attr->type & 0x80);
11104 val = read_uleb128 (p, &len);
11105 p += len;
11106 type = attr->type & 0x7f;
11107 if (val >= type)
11108 printf ("??? (%d)\n", val);
11109 else
11110 printf ("%s\n", attr->table[val]);
11111 return p;
11112 }
11113 }
11114 else
11115 {
11116 if (tag & 1)
11117 type = 1; /* String. */
11118 else
11119 type = 2; /* uleb128. */
11120 printf (" Tag_unknown_%d: ", tag);
11121 }
11122
11123 if (type == 1)
11124 {
11125 printf ("\"%s\"\n", p);
2cf0635d 11126 p += strlen ((char *) p) + 1;
11c1ff18
PB		 11127 }
11128 else
11129 {
11130 val = read_uleb128 (p, &len);
11131 p += len;
11132 printf ("%d (0x%x)\n", val, val);
11133 }
11134
11135 return p;
11136}
11137
104d59d1 11138static unsigned char *
60bca95a
NC		 11139display_gnu_attribute (unsigned char * p,
11140 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
104d59d1
JM		 11141{
11142 int tag;
11143 unsigned int len;
11144 int val;
11145 int type;
11146
11147 tag = read_uleb128 (p, &len);
11148 p += len;
11149
11150 /* Tag_compatibility is the only generic GNU attribute defined at
11151 present. */
11152 if (tag == 32)
11153 {
11154 val = read_uleb128 (p, &len);
11155 p += len;
2b692964 11156 printf (_("flag = %d, vendor = %s\n"), val, p);
60bca95a 11157 p += strlen ((char *) p) + 1;
104d59d1
JM		 11158 return p;
11159 }
11160
11161 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11162 return display_proc_gnu_attribute (p, tag);
11163
11164 if (tag & 1)
11165 type = 1; /* String. */
11166 else
11167 type = 2; /* uleb128. */
11168 printf (" Tag_unknown_%d: ", tag);
11169
11170 if (type == 1)
11171 {
11172 printf ("\"%s\"\n", p);
60bca95a 11173 p += strlen ((char *) p) + 1;
104d59d1
JM		 11174 }
11175 else
11176 {
11177 val = read_uleb128 (p, &len);
11178 p += len;
11179 printf ("%d (0x%x)\n", val, val);
11180 }
11181
11182 return p;
11183}
11184
34c8bcba 11185static unsigned char *
2cf0635d 11186display_power_gnu_attribute (unsigned char * p, int tag)
34c8bcba
JM		 11187{
11188 int type;
11189 unsigned int len;
11190 int val;
11191
11192 if (tag == Tag_GNU_Power_ABI_FP)
11193 {
11194 val = read_uleb128 (p, &len);
11195 p += len;
11196 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 11197
34c8bcba
JM		 11198 switch (val)
11199 {
11200 case 0:
2b692964 11201 printf (_("Hard or soft float\n"));
34c8bcba
JM		 11202 break;
11203 case 1:
2b692964 11204 printf (_("Hard float\n"));
34c8bcba
JM		 11205 break;
11206 case 2:
2b692964 11207 printf (_("Soft float\n"));
34c8bcba 11208 break;
3c7b9897 11209 case 3:
2b692964 11210 printf (_("Single-precision hard float\n"));
3c7b9897 11211 break;
34c8bcba
JM		 11212 default:
11213 printf ("??? (%d)\n", val);
11214 break;
11215 }
11216 return p;
11217 }
11218
c6e65352
DJ		 11219 if (tag == Tag_GNU_Power_ABI_Vector)
11220 {
11221 val = read_uleb128 (p, &len);
11222 p += len;
11223 printf (" Tag_GNU_Power_ABI_Vector: ");
11224 switch (val)
11225 {
11226 case 0:
2b692964 11227 printf (_("Any\n"));
c6e65352
DJ		 11228 break;
11229 case 1:
2b692964 11230 printf (_("Generic\n"));
c6e65352
DJ		 11231 break;
11232 case 2:
11233 printf ("AltiVec\n");
11234 break;
11235 case 3:
11236 printf ("SPE\n");
11237 break;
11238 default:
11239 printf ("??? (%d)\n", val);
11240 break;
11241 }
11242 return p;
11243 }
11244
f82e0623
NF		 11245 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11246 {
11247 val = read_uleb128 (p, &len);
11248 p += len;
11249 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11250 switch (val)
11251 {
11252 case 0:
2b692964 11253 printf (_("Any\n"));
f82e0623
NF		 11254 break;
11255 case 1:
11256 printf ("r3/r4\n");
11257 break;
11258 case 2:
2b692964 11259 printf (_("Memory\n"));
f82e0623
NF		 11260 break;
11261 default:
11262 printf ("??? (%d)\n", val);
11263 break;
11264 }
11265 return p;
11266 }
11267
34c8bcba
JM		 11268 if (tag & 1)
11269 type = 1; /* String. */
11270 else
11271 type = 2; /* uleb128. */
11272 printf (" Tag_unknown_%d: ", tag);
11273
11274 if (type == 1)
11275 {
11276 printf ("\"%s\"\n", p);
60bca95a 11277 p += strlen ((char *) p) + 1;
34c8bcba
JM		 11278 }
11279 else
11280 {
11281 val = read_uleb128 (p, &len);
11282 p += len;
11283 printf ("%d (0x%x)\n", val, val);
11284 }
11285
11286 return p;
11287}
11288
9e8c70f9
DM		 11289static void
11290display_sparc_hwcaps (int mask)
11291{
11292 if (mask)
11293 {
11294 int first = 1;
11295 if (mask & ELF_SPARC_HWCAP_MUL32)
11296 fputs ("mul32", stdout), first = 0;
11297 if (mask & ELF_SPARC_HWCAP_DIV32)
11298 printf ("%sdiv32", first ? "" : "|"), first = 0;
11299 if (mask & ELF_SPARC_HWCAP_FSMULD)
11300 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11301 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11302 printf ("%sv8plus", first ? "" : "|"), first = 0;
11303 if (mask & ELF_SPARC_HWCAP_POPC)
11304 printf ("%spopc", first ? "" : "|"), first = 0;
11305 if (mask & ELF_SPARC_HWCAP_VIS)
11306 printf ("%svis", first ? "" : "|"), first = 0;
11307 if (mask & ELF_SPARC_HWCAP_VIS2)
11308 printf ("%svis2", first ? "" : "|"), first = 0;
11309 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11310 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11311 if (mask & ELF_SPARC_HWCAP_FMAF)
11312 printf ("%sfmaf", first ? "" : "|"), first = 0;
11313 if (mask & ELF_SPARC_HWCAP_VIS3)
11314 printf ("%svis3", first ? "" : "|"), first = 0;
11315 if (mask & ELF_SPARC_HWCAP_HPC)
11316 printf ("%shpc", first ? "" : "|"), first = 0;
11317 if (mask & ELF_SPARC_HWCAP_RANDOM)
11318 printf ("%srandom", first ? "" : "|"), first = 0;
11319 if (mask & ELF_SPARC_HWCAP_TRANS)
11320 printf ("%strans", first ? "" : "|"), first = 0;
11321 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11322 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11323 if (mask & ELF_SPARC_HWCAP_IMA)
11324 printf ("%sima", first ? "" : "|"), first = 0;
11325 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11326 printf ("%scspare", first ? "" : "|"), first = 0;
11327 }
11328 else
11329 fputc('0', stdout);
11330 fputc('\n', stdout);
11331}
11332
11333static unsigned char *
11334display_sparc_gnu_attribute (unsigned char * p, int tag)
11335{
11336 int type;
11337 unsigned int len;
11338 int val;
11339
11340 if (tag == Tag_GNU_Sparc_HWCAPS)
11341 {
11342 val = read_uleb128 (p, &len);
11343 p += len;
11344 printf (" Tag_GNU_Sparc_HWCAPS: ");
11345
11346 display_sparc_hwcaps (val);
11347 return p;
11348 }
11349
11350 if (tag & 1)
11351 type = 1; /* String. */
11352 else
11353 type = 2; /* uleb128. */
11354 printf (" Tag_unknown_%d: ", tag);
11355
11356 if (type == 1)
11357 {
11358 printf ("\"%s\"\n", p);
11359 p += strlen ((char *) p) + 1;
11360 }
11361 else
11362 {
11363 val = read_uleb128 (p, &len);
11364 p += len;
11365 printf ("%d (0x%x)\n", val, val);
11366 }
11367
11368 return p;
11369}
11370
2cf19d5c 11371static unsigned char *
2cf0635d 11372display_mips_gnu_attribute (unsigned char * p, int tag)
2cf19d5c
JM		 11373{
11374 int type;
11375 unsigned int len;
11376 int val;
11377
11378 if (tag == Tag_GNU_MIPS_ABI_FP)
11379 {
11380 val = read_uleb128 (p, &len);
11381 p += len;
11382 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 11383
2cf19d5c
JM		 11384 switch (val)
11385 {
11386 case 0:
2b692964 11387 printf (_("Hard or soft float\n"));
2cf19d5c
JM		 11388 break;
11389 case 1:
2b692964 11390 printf (_("Hard float (double precision)\n"));
2cf19d5c
JM		 11391 break;
11392 case 2:
2b692964 11393 printf (_("Hard float (single precision)\n"));
2cf19d5c
JM		 11394 break;
11395 case 3:
2b692964 11396 printf (_("Soft float\n"));
2cf19d5c 11397 break;
42554f6a 11398 case 4:
9eeefea8 11399 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
42554f6a 11400 break;
2cf19d5c
JM		 11401 default:
11402 printf ("??? (%d)\n", val);
11403 break;
11404 }
11405 return p;
11406 }
11407
11408 if (tag & 1)
11409 type = 1; /* String. */
11410 else
11411 type = 2; /* uleb128. */
11412 printf (" Tag_unknown_%d: ", tag);
11413
11414 if (type == 1)
11415 {
11416 printf ("\"%s\"\n", p);
60bca95a 11417 p += strlen ((char *) p) + 1;
2cf19d5c
JM		 11418 }
11419 else
11420 {
11421 val = read_uleb128 (p, &len);
11422 p += len;
11423 printf ("%d (0x%x)\n", val, val);
11424 }
11425
11426 return p;
11427}
11428
59e6276b
JM		 11429static unsigned char *
11430display_tic6x_attribute (unsigned char * p)
11431{
11432 int tag;
11433 unsigned int len;
11434 int val;
11435
11436 tag = read_uleb128 (p, &len);
11437 p += len;
11438
11439 switch (tag)
11440 {
75fa6dc1 11441 case Tag_ISA:
59e6276b
JM		 11442 val = read_uleb128 (p, &len);
11443 p += len;
75fa6dc1 11444 printf (" Tag_ISA: ");
59e6276b
JM		 11445
11446 switch (val)
11447 {
75fa6dc1 11448 case C6XABI_Tag_ISA_none:
59e6276b
JM		 11449 printf (_("None\n"));
11450 break;
75fa6dc1 11451 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 11452 printf ("C62x\n");
11453 break;
75fa6dc1 11454 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 11455 printf ("C67x\n");
11456 break;
75fa6dc1 11457 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 11458 printf ("C67x+\n");
11459 break;
75fa6dc1 11460 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 11461 printf ("C64x\n");
11462 break;
75fa6dc1 11463 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 11464 printf ("C64x+\n");
11465 break;
75fa6dc1 11466 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 11467 printf ("C674x\n");
11468 break;
11469 default:
11470 printf ("??? (%d)\n", val);
11471 break;
11472 }
11473 return p;
11474
87779176
JM		 11475 case Tag_ABI_wchar_t:
11476 val = read_uleb128 (p, &len);
11477 p += len;
11478 printf (" Tag_ABI_wchar_t: ");
11479 switch (val)
11480 {
11481 case 0:
11482 printf (_("Not used\n"));
11483 break;
11484 case 1:
11485 printf (_("2 bytes\n"));
11486 break;
11487 case 2:
11488 printf (_("4 bytes\n"));
11489 break;
11490 default:
11491 printf ("??? (%d)\n", val);
11492 break;
11493 }
11494 return p;
11495
11496 case Tag_ABI_stack_align_needed:
11497 val = read_uleb128 (p, &len);
11498 p += len;
11499 printf (" Tag_ABI_stack_align_needed: ");
11500 switch (val)
11501 {
11502 case 0:
11503 printf (_("8-byte\n"));
11504 break;
11505 case 1:
11506 printf (_("16-byte\n"));
11507 break;
11508 default:
11509 printf ("??? (%d)\n", val);
11510 break;
11511 }
11512 return p;
11513
11514 case Tag_ABI_stack_align_preserved:
11515 val = read_uleb128 (p, &len);
11516 p += len;
11517 printf (" Tag_ABI_stack_align_preserved: ");
11518 switch (val)
11519 {
11520 case 0:
11521 printf (_("8-byte\n"));
11522 break;
11523 case 1:
11524 printf (_("16-byte\n"));
11525 break;
11526 default:
11527 printf ("??? (%d)\n", val);
11528 break;
11529 }
11530 return p;
11531
b5593623
JM		 11532 case Tag_ABI_DSBT:
11533 val = read_uleb128 (p, &len);
11534 p += len;
11535 printf (" Tag_ABI_DSBT: ");
11536 switch (val)
11537 {
11538 case 0:
11539 printf (_("DSBT addressing not used\n"));
11540 break;
11541 case 1:
11542 printf (_("DSBT addressing used\n"));
11543 break;
11544 default:
11545 printf ("??? (%d)\n", val);
11546 break;
11547 }
11548 return p;
11549
87779176
JM		 11550 case Tag_ABI_PID:
11551 val = read_uleb128 (p, &len);
11552 p += len;
11553 printf (" Tag_ABI_PID: ");
11554 switch (val)
11555 {
11556 case 0:
11557 printf (_("Data addressing position-dependent\n"));
11558 break;
11559 case 1:
11560 printf (_("Data addressing position-independent, GOT near DP\n"));
11561 break;
11562 case 2:
11563 printf (_("Data addressing position-independent, GOT far from DP\n"));
11564 break;
11565 default:
11566 printf ("??? (%d)\n", val);
11567 break;
11568 }
11569 return p;
11570
11571 case Tag_ABI_PIC:
11572 val = read_uleb128 (p, &len);
11573 p += len;
11574 printf (" Tag_ABI_PIC: ");
11575 switch (val)
11576 {
11577 case 0:
11578 printf (_("Code addressing position-dependent\n"));
11579 break;
11580 case 1:
11581 printf (_("Code addressing position-independent\n"));
11582 break;
11583 default:
11584 printf ("??? (%d)\n", val);
11585 break;
11586 }
11587 return p;
11588
11589 case Tag_ABI_array_object_alignment:
11590 val = read_uleb128 (p, &len);
11591 p += len;
11592 printf (" Tag_ABI_array_object_alignment: ");
11593 switch (val)
11594 {
11595 case 0:
11596 printf (_("8-byte\n"));
11597 break;
11598 case 1:
11599 printf (_("4-byte\n"));
11600 break;
11601 case 2:
11602 printf (_("16-byte\n"));
11603 break;
11604 default:
11605 printf ("??? (%d)\n", val);
11606 break;
11607 }
11608 return p;
11609
11610 case Tag_ABI_array_object_align_expected:
11611 val = read_uleb128 (p, &len);
11612 p += len;
11613 printf (" Tag_ABI_array_object_align_expected: ");
11614 switch (val)
11615 {
11616 case 0:
11617 printf (_("8-byte\n"));
11618 break;
11619 case 1:
11620 printf (_("4-byte\n"));
11621 break;
11622 case 2:
11623 printf (_("16-byte\n"));
11624 break;
11625 default:
11626 printf ("??? (%d)\n", val);
11627 break;
11628 }
11629 return p;
11630
3cbd1c06 11631 case Tag_ABI_compatibility:
59e6276b
JM		 11632 val = read_uleb128 (p, &len);
11633 p += len;
3cbd1c06 11634 printf (" Tag_ABI_compatibility: ");
59e6276b
JM		 11635 printf (_("flag = %d, vendor = %s\n"), val, p);
11636 p += strlen ((char *) p) + 1;
11637 return p;
87779176
JM		 11638
11639 case Tag_ABI_conformance:
11640 printf (" Tag_ABI_conformance: ");
11641 printf ("\"%s\"\n", p);
11642 p += strlen ((char *) p) + 1;
11643 return p;
59e6276b
JM		 11644 }
11645
11646 printf (" Tag_unknown_%d: ", tag);
11647
87779176
JM		 11648 if (tag & 1)
11649 {
11650 printf ("\"%s\"\n", p);
11651 p += strlen ((char *) p) + 1;
11652 }
11653 else
11654 {
11655 val = read_uleb128 (p, &len);
11656 p += len;
11657 printf ("%d (0x%x)\n", val, val);
11658 }
59e6276b
JM		 11659
11660 return p;
11661}
11662
11c1ff18 11663static int
60bca95a
NC		 11664process_attributes (FILE * file,
11665 const char * public_name,
104d59d1 11666 unsigned int proc_type,
60bca95a
NC		 11667 unsigned char * (* display_pub_attribute) (unsigned char *),
11668 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11c1ff18 11669{
2cf0635d
NC		 11670 Elf_Internal_Shdr * sect;
11671 unsigned char * contents;
11672 unsigned char * p;
11673 unsigned char * end;
11c1ff18
PB		 11674 bfd_vma section_len;
11675 bfd_vma len;
11676 unsigned i;
11677
11678 /* Find the section header so that we get the size. */
11679 for (i = 0, sect = section_headers;
11680 i < elf_header.e_shnum;
11681 i++, sect++)
11682 {
104d59d1 11683 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 11684 continue;
11685
3f5e193b
NC		 11686 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11687 sect->sh_size, _("attributes"));
60bca95a 11688 if (contents == NULL)
11c1ff18 11689 continue;
60bca95a 11690
11c1ff18
PB		 11691 p = contents;
11692 if (*p == 'A')
11693 {
11694 len = sect->sh_size - 1;
11695 p++;
60bca95a 11696
11c1ff18
PB		 11697 while (len > 0)
11698 {
11699 int namelen;
11700 bfd_boolean public_section;
104d59d1 11701 bfd_boolean gnu_section;
11c1ff18
PB		 11702
11703 section_len = byte_get (p, 4);
11704 p += 4;
60bca95a 11705
11c1ff18
PB		 11706 if (section_len > len)
11707 {
11708 printf (_("ERROR: Bad section length (%d > %d)\n"),
60bca95a 11709 (int) section_len, (int) len);
11c1ff18
PB		 11710 section_len = len;
11711 }
60bca95a 11712
11c1ff18 11713 len -= section_len;
2b692964 11714 printf (_("Attribute Section: %s\n"), p);
60bca95a
NC		 11715
11716 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 11717 public_section = TRUE;
11718 else
11719 public_section = FALSE;
60bca95a
NC		 11720
11721 if (streq ((char *) p, "gnu"))
104d59d1
JM		 11722 gnu_section = TRUE;
11723 else
11724 gnu_section = FALSE;
60bca95a
NC		 11725
11726 namelen = strlen ((char *) p) + 1;
11c1ff18
PB		 11727 p += namelen;
11728 section_len -= namelen + 4;
60bca95a 11729
11c1ff18
PB		 11730 while (section_len > 0)
11731 {
11732 int tag = *(p++);
11733 int val;
11734 bfd_vma size;
60bca95a 11735
11c1ff18
PB		 11736 size = byte_get (p, 4);
11737 if (size > section_len)
11738 {
11739 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
60bca95a 11740 (int) size, (int) section_len);
11c1ff18
PB		 11741 size = section_len;
11742 }
60bca95a 11743
11c1ff18
PB		 11744 section_len -= size;
11745 end = p + size - 1;
11746 p += 4;
60bca95a 11747
11c1ff18
PB		 11748 switch (tag)
11749 {
11750 case 1:
2b692964 11751 printf (_("File Attributes\n"));
11c1ff18
PB		 11752 break;
11753 case 2:
2b692964 11754 printf (_("Section Attributes:"));
11c1ff18
PB		 11755 goto do_numlist;
11756 case 3:
2b692964 11757 printf (_("Symbol Attributes:"));
11c1ff18
PB		 11758 do_numlist:
11759 for (;;)
11760 {
91d6fa6a 11761 unsigned int j;
60bca95a 11762
91d6fa6a
NC		 11763 val = read_uleb128 (p, &j);
11764 p += j;
11c1ff18
PB		 11765 if (val == 0)
11766 break;
11767 printf (" %d", val);
11768 }
11769 printf ("\n");
11770 break;
11771 default:
2b692964 11772 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 11773 public_section = FALSE;
11774 break;
11775 }
60bca95a 11776
11c1ff18
PB		 11777 if (public_section)
11778 {
11779 while (p < end)
104d59d1
JM		 11780 p = display_pub_attribute (p);
11781 }
11782 else if (gnu_section)
11783 {
11784 while (p < end)
11785 p = display_gnu_attribute (p,
11786 display_proc_gnu_attribute);
11c1ff18
PB		 11787 }
11788 else
11789 {
11790 /* ??? Do something sensible, like dump hex. */
2b692964 11791 printf (_(" Unknown section contexts\n"));
11c1ff18
PB		 11792 p = end;
11793 }
11794 }
11795 }
11796 }
11797 else
60bca95a 11798 printf (_("Unknown format '%c'\n"), *p);
d70c5fc7 11799
60bca95a 11800 free (contents);
11c1ff18
PB		 11801 }
11802 return 1;
11803}
11804
104d59d1 11805static int
2cf0635d 11806process_arm_specific (FILE * file)
104d59d1
JM		 11807{
11808 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11809 display_arm_attribute, NULL);
11810}
11811
34c8bcba 11812static int
2cf0635d 11813process_power_specific (FILE * file)
34c8bcba
JM		 11814{
11815 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11816 display_power_gnu_attribute);
11817}
11818
9e8c70f9
DM		 11819static int
11820process_sparc_specific (FILE * file)
11821{
11822 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11823 display_sparc_gnu_attribute);
11824}
11825
59e6276b
JM		 11826static int
11827process_tic6x_specific (FILE * file)
11828{
11829 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11830 display_tic6x_attribute, NULL);
11831}
11832
ccb4c951
RS		 11833/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11834 Print the Address, Access and Initial fields of an entry at VMA ADDR
11835 and return the VMA of the next entry. */
11836
11837static bfd_vma
2cf0635d 11838print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
ccb4c951
RS		 11839{
11840 printf (" ");
11841 print_vma (addr, LONG_HEX);
11842 printf (" ");
11843 if (addr < pltgot + 0xfff0)
11844 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11845 else
11846 printf ("%10s", "");
11847 printf (" ");
11848 if (data == NULL)
2b692964 11849 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 11850 else
11851 {
11852 bfd_vma entry;
11853
11854 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11855 print_vma (entry, LONG_HEX);
11856 }
11857 return addr + (is_32bit_elf ? 4 : 8);
11858}
11859
861fb55a
DJ		 11860/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11861 PLTGOT. Print the Address and Initial fields of an entry at VMA
11862 ADDR and return the VMA of the next entry. */
11863
11864static bfd_vma
2cf0635d 11865print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 11866{
11867 printf (" ");
11868 print_vma (addr, LONG_HEX);
11869 printf (" ");
11870 if (data == NULL)
2b692964 11871 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 11872 else
11873 {
11874 bfd_vma entry;
11875
11876 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11877 print_vma (entry, LONG_HEX);
11878 }
11879 return addr + (is_32bit_elf ? 4 : 8);
11880}
11881
19e6b90e 11882static int
2cf0635d 11883process_mips_specific (FILE * file)
5b18a4bc 11884{
2cf0635d 11885 Elf_Internal_Dyn * entry;
19e6b90e
L		 11886 size_t liblist_offset = 0;
11887 size_t liblistno = 0;
11888 size_t conflictsno = 0;
11889 size_t options_offset = 0;
11890 size_t conflicts_offset = 0;
861fb55a
DJ		 11891 size_t pltrelsz = 0;
11892 size_t pltrel = 0;
ccb4c951 11893 bfd_vma pltgot = 0;
861fb55a
DJ		 11894 bfd_vma mips_pltgot = 0;
11895 bfd_vma jmprel = 0;
ccb4c951
RS		 11896 bfd_vma local_gotno = 0;
11897 bfd_vma gotsym = 0;
11898 bfd_vma symtabno = 0;
103f02d3 11899
2cf19d5c
JM		 11900 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11901 display_mips_gnu_attribute);
11902
19e6b90e
L		 11903 /* We have a lot of special sections. Thanks SGI! */
11904 if (dynamic_section == NULL)
11905 /* No information available. */
11906 return 0;
252b5132 11907
b2d38a17 11908 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
252b5132
RH		 11909 switch (entry->d_tag)
11910 {
11911 case DT_MIPS_LIBLIST:
d93f0186
NC		 11912 liblist_offset
11913 = offset_from_vma (file, entry->d_un.d_val,
11914 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 11915 break;
11916 case DT_MIPS_LIBLISTNO:
11917 liblistno = entry->d_un.d_val;
11918 break;
11919 case DT_MIPS_OPTIONS:
d93f0186 11920 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 11921 break;
11922 case DT_MIPS_CONFLICT:
d93f0186
NC		 11923 conflicts_offset
11924 = offset_from_vma (file, entry->d_un.d_val,
11925 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 11926 break;
11927 case DT_MIPS_CONFLICTNO:
11928 conflictsno = entry->d_un.d_val;
11929 break;
ccb4c951 11930 case DT_PLTGOT:
861fb55a
DJ		 11931 pltgot = entry->d_un.d_ptr;
11932 break;
ccb4c951
RS		 11933 case DT_MIPS_LOCAL_GOTNO:
11934 local_gotno = entry->d_un.d_val;
11935 break;
11936 case DT_MIPS_GOTSYM:
11937 gotsym = entry->d_un.d_val;
11938 break;
11939 case DT_MIPS_SYMTABNO:
11940 symtabno = entry->d_un.d_val;
11941 break;
861fb55a
DJ		 11942 case DT_MIPS_PLTGOT:
11943 mips_pltgot = entry->d_un.d_ptr;
11944 break;
11945 case DT_PLTREL:
11946 pltrel = entry->d_un.d_val;
11947 break;
11948 case DT_PLTRELSZ:
11949 pltrelsz = entry->d_un.d_val;
11950 break;
11951 case DT_JMPREL:
11952 jmprel = entry->d_un.d_ptr;
11953 break;
252b5132
RH		 11954 default:
11955 break;
11956 }
11957
11958 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11959 {
2cf0635d 11960 Elf32_External_Lib * elib;
252b5132
RH		 11961 size_t cnt;
11962
3f5e193b
NC		 11963 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11964 liblistno,
11965 sizeof (Elf32_External_Lib),
9cf03b7e 11966 _("liblist section data"));
a6e9f9df 11967 if (elib)
252b5132 11968 {
2b692964 11969 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 11970 (unsigned long) liblistno);
2b692964 11971 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 11972 stdout);
11973
11974 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 11975 {
a6e9f9df 11976 Elf32_Lib liblist;
91d6fa6a 11977 time_t atime;
a6e9f9df 11978 char timebuf[20];
2cf0635d 11979 struct tm * tmp;
a6e9f9df
AM		 11980
11981 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 11982 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 11983 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11984 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11985 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11986
91d6fa6a 11987 tmp = gmtime (&atime);
e9e44622
JJ		 11988 snprintf (timebuf, sizeof (timebuf),
11989 "%04u-%02u-%02uT%02u:%02u:%02u",
11990 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11991 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 11992
31104126 11993 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 11994 if (VALID_DYNAMIC_NAME (liblist.l_name))
11995 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11996 else
2b692964 11997 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 11998 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11999 liblist.l_version);
a6e9f9df
AM		 12000
12001 if (liblist.l_flags == 0)
2b692964 12002 puts (_(" NONE"));
a6e9f9df
AM		 12003 else
12004 {
12005 static const struct
252b5132 12006 {
2cf0635d 12007 const char * name;
a6e9f9df 12008 int bit;
252b5132 12009 }
a6e9f9df
AM		 12010 l_flags_vals[] =
12011 {
12012 { " EXACT_MATCH", LL_EXACT_MATCH },
12013 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12014 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12015 { " EXPORTS", LL_EXPORTS },
12016 { " DELAY_LOAD", LL_DELAY_LOAD },
12017 { " DELTA", LL_DELTA }
12018 };
12019 int flags = liblist.l_flags;
12020 size_t fcnt;
12021
60bca95a 12022 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 12023 if ((flags & l_flags_vals[fcnt].bit) != 0)
12024 {
12025 fputs (l_flags_vals[fcnt].name, stdout);
12026 flags ^= l_flags_vals[fcnt].bit;
12027 }
12028 if (flags != 0)
12029 printf (" %#x", (unsigned int) flags);
252b5132 12030
a6e9f9df
AM		 12031 puts ("");
12032 }
252b5132 12033 }
252b5132 12034
a6e9f9df
AM		 12035 free (elib);
12036 }
252b5132
RH		 12037 }
12038
12039 if (options_offset != 0)
12040 {
2cf0635d
NC		 12041 Elf_External_Options * eopt;
12042 Elf_Internal_Shdr * sect = section_headers;
12043 Elf_Internal_Options * iopt;
12044 Elf_Internal_Options * option;
252b5132
RH		 12045 size_t offset;
12046 int cnt;
12047
12048 /* Find the section header so that we get the size. */
12049 while (sect->sh_type != SHT_MIPS_OPTIONS)
b34976b6 12050 ++sect;
252b5132 12051
3f5e193b
NC		 12052 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12053 sect->sh_size, _("options"));
a6e9f9df 12054 if (eopt)
252b5132 12055 {
3f5e193b
NC		 12056 iopt = (Elf_Internal_Options *)
12057 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 12058 if (iopt == NULL)
12059 {
591a748a 12060 error (_("Out of memory\n"));
a6e9f9df
AM		 12061 return 0;
12062 }
76da6bbe 12063
a6e9f9df
AM		 12064 offset = cnt = 0;
12065 option = iopt;
252b5132 12066
a6e9f9df
AM		 12067 while (offset < sect->sh_size)
12068 {
2cf0635d 12069 Elf_External_Options * eoption;
252b5132 12070
a6e9f9df 12071 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 12072
a6e9f9df
AM		 12073 option->kind = BYTE_GET (eoption->kind);
12074 option->size = BYTE_GET (eoption->size);
12075 option->section = BYTE_GET (eoption->section);
12076 option->info = BYTE_GET (eoption->info);
76da6bbe 12077
a6e9f9df 12078 offset += option->size;
252b5132 12079
a6e9f9df
AM		 12080 ++option;
12081 ++cnt;
12082 }
252b5132 12083
a6e9f9df
AM		 12084 printf (_("\nSection '%s' contains %d entries:\n"),
12085 SECTION_NAME (sect), cnt);
76da6bbe 12086
a6e9f9df 12087 option = iopt;
252b5132 12088
a6e9f9df 12089 while (cnt-- > 0)
252b5132 12090 {
a6e9f9df
AM		 12091 size_t len;
12092
12093 switch (option->kind)
252b5132 12094 {
a6e9f9df
AM		 12095 case ODK_NULL:
12096 /* This shouldn't happen. */
12097 printf (" NULL %d %lx", option->section, option->info);
12098 break;
12099 case ODK_REGINFO:
12100 printf (" REGINFO ");
12101 if (elf_header.e_machine == EM_MIPS)
12102 {
12103 /* 32bit form. */
2cf0635d 12104 Elf32_External_RegInfo * ereg;
b34976b6 12105 Elf32_RegInfo reginfo;
a6e9f9df
AM		 12106
12107 ereg = (Elf32_External_RegInfo *) (option + 1);
12108 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12109 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12110 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12111 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12112 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12113 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12114
12115 printf ("GPR %08lx GP 0x%lx\n",
12116 reginfo.ri_gprmask,
12117 (unsigned long) reginfo.ri_gp_value);
12118 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12119 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12120 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12121 }
12122 else
12123 {
12124 /* 64 bit form. */
2cf0635d 12125 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 12126 Elf64_Internal_RegInfo reginfo;
12127
12128 ereg = (Elf64_External_RegInfo *) (option + 1);
12129 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12130 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12131 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12132 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12133 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 12134 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 12135
12136 printf ("GPR %08lx GP 0x",
12137 reginfo.ri_gprmask);
12138 printf_vma (reginfo.ri_gp_value);
12139 printf ("\n");
12140
12141 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12142 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12143 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12144 }
12145 ++option;
12146 continue;
12147 case ODK_EXCEPTIONS:
12148 fputs (" EXCEPTIONS fpe_min(", stdout);
12149 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12150 fputs (") fpe_max(", stdout);
12151 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12152 fputs (")", stdout);
12153
12154 if (option->info & OEX_PAGE0)
12155 fputs (" PAGE0", stdout);
12156 if (option->info & OEX_SMM)
12157 fputs (" SMM", stdout);
12158 if (option->info & OEX_FPDBUG)
12159 fputs (" FPDBUG", stdout);
12160 if (option->info & OEX_DISMISS)
12161 fputs (" DISMISS", stdout);
12162 break;
12163 case ODK_PAD:
12164 fputs (" PAD ", stdout);
12165 if (option->info & OPAD_PREFIX)
12166 fputs (" PREFIX", stdout);
12167 if (option->info & OPAD_POSTFIX)
12168 fputs (" POSTFIX", stdout);
12169 if (option->info & OPAD_SYMBOL)
12170 fputs (" SYMBOL", stdout);
12171 break;
12172 case ODK_HWPATCH:
12173 fputs (" HWPATCH ", stdout);
12174 if (option->info & OHW_R4KEOP)
12175 fputs (" R4KEOP", stdout);
12176 if (option->info & OHW_R8KPFETCH)
12177 fputs (" R8KPFETCH", stdout);
12178 if (option->info & OHW_R5KEOP)
12179 fputs (" R5KEOP", stdout);
12180 if (option->info & OHW_R5KCVTL)
12181 fputs (" R5KCVTL", stdout);
12182 break;
12183 case ODK_FILL:
12184 fputs (" FILL ", stdout);
12185 /* XXX Print content of info word? */
12186 break;
12187 case ODK_TAGS:
12188 fputs (" TAGS ", stdout);
12189 /* XXX Print content of info word? */
12190 break;
12191 case ODK_HWAND:
12192 fputs (" HWAND ", stdout);
12193 if (option->info & OHWA0_R4KEOP_CHECKED)
12194 fputs (" R4KEOP_CHECKED", stdout);
12195 if (option->info & OHWA0_R4KEOP_CLEAN)
12196 fputs (" R4KEOP_CLEAN", stdout);
12197 break;
12198 case ODK_HWOR:
12199 fputs (" HWOR ", stdout);
12200 if (option->info & OHWA0_R4KEOP_CHECKED)
12201 fputs (" R4KEOP_CHECKED", stdout);
12202 if (option->info & OHWA0_R4KEOP_CLEAN)
12203 fputs (" R4KEOP_CLEAN", stdout);
12204 break;
12205 case ODK_GP_GROUP:
12206 printf (" GP_GROUP %#06lx self-contained %#06lx",
12207 option->info & OGP_GROUP,
12208 (option->info & OGP_SELF) >> 16);
12209 break;
12210 case ODK_IDENT:
12211 printf (" IDENT %#06lx self-contained %#06lx",
12212 option->info & OGP_GROUP,
12213 (option->info & OGP_SELF) >> 16);
12214 break;
12215 default:
12216 /* This shouldn't happen. */
12217 printf (" %3d ??? %d %lx",
12218 option->kind, option->section, option->info);
12219 break;
252b5132 12220 }
a6e9f9df 12221
2cf0635d 12222 len = sizeof (* eopt);
a6e9f9df
AM		 12223 while (len < option->size)
12224 if (((char *) option)[len] >= ' '
12225 && ((char *) option)[len] < 0x7f)
12226 printf ("%c", ((char *) option)[len++]);
12227 else
12228 printf ("\\%03o", ((char *) option)[len++]);
12229
12230 fputs ("\n", stdout);
252b5132 12231 ++option;
252b5132
RH		 12232 }
12233
a6e9f9df 12234 free (eopt);
252b5132 12235 }
252b5132
RH		 12236 }
12237
12238 if (conflicts_offset != 0 && conflictsno != 0)
12239 {
2cf0635d 12240 Elf32_Conflict * iconf;
252b5132
RH		 12241 size_t cnt;
12242
12243 if (dynamic_symbols == NULL)
12244 {
591a748a 12245 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 12246 return 0;
12247 }
12248
3f5e193b 12249 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 12250 if (iconf == NULL)
12251 {
591a748a 12252 error (_("Out of memory\n"));
252b5132
RH		 12253 return 0;
12254 }
12255
9ea033b2 12256 if (is_32bit_elf)
252b5132 12257 {
2cf0635d 12258 Elf32_External_Conflict * econf32;
a6e9f9df 12259
3f5e193b
NC		 12260 econf32 = (Elf32_External_Conflict *)
12261 get_data (NULL, file, conflicts_offset, conflictsno,
12262 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 12263 if (!econf32)
12264 return 0;
252b5132
RH		 12265
12266 for (cnt = 0; cnt < conflictsno; ++cnt)
12267 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 12268
12269 free (econf32);
252b5132
RH		 12270 }
12271 else
12272 {
2cf0635d 12273 Elf64_External_Conflict * econf64;
a6e9f9df 12274
3f5e193b
NC		 12275 econf64 = (Elf64_External_Conflict *)
12276 get_data (NULL, file, conflicts_offset, conflictsno,
12277 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 12278 if (!econf64)
12279 return 0;
252b5132
RH		 12280
12281 for (cnt = 0; cnt < conflictsno; ++cnt)
12282 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 12283
12284 free (econf64);
252b5132
RH		 12285 }
12286
c7e7ca54
NC		 12287 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12288 (unsigned long) conflictsno);
252b5132
RH		 12289 puts (_(" Num: Index Value Name"));
12290
12291 for (cnt = 0; cnt < conflictsno; ++cnt)
12292 {
2cf0635d 12293 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
252b5132 12294
b34976b6 12295 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963 12296 print_vma (psym->st_value, FULL_HEX);
31104126 12297 putchar (' ');
d79b3d50
NC		 12298 if (VALID_DYNAMIC_NAME (psym->st_name))
12299 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12300 else
2b692964 12301 printf (_("<corrupt: %14ld>"), psym->st_name);
31104126 12302 putchar ('\n');
252b5132
RH		 12303 }
12304
252b5132
RH		 12305 free (iconf);
12306 }
12307
ccb4c951
RS		 12308 if (pltgot != 0 && local_gotno != 0)
12309 {
91d6fa6a 12310 bfd_vma ent, local_end, global_end;
bbeee7ea 12311 size_t i, offset;
2cf0635d 12312 unsigned char * data;
bbeee7ea 12313 int addr_size;
ccb4c951 12314
91d6fa6a 12315 ent = pltgot;
ccb4c951
RS		 12316 addr_size = (is_32bit_elf ? 4 : 8);
12317 local_end = pltgot + local_gotno * addr_size;
12318 global_end = local_end + (symtabno - gotsym) * addr_size;
12319
12320 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 12321 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 12322 global_end - pltgot, 1,
12323 _("Global Offset Table data"));
59245841
NC		 12324 if (data == NULL)
12325 return 0;
12326
ccb4c951
RS		 12327 printf (_("\nPrimary GOT:\n"));
12328 printf (_(" Canonical gp value: "));
12329 print_vma (pltgot + 0x7ff0, LONG_HEX);
12330 printf ("\n\n");
12331
12332 printf (_(" Reserved entries:\n"));
12333 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 12334 addr_size * 2, _("Address"), _("Access"),
12335 addr_size * 2, _("Initial"));
91d6fa6a 12336 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12337 printf (_(" Lazy resolver\n"));
ccb4c951 12338 if (data
91d6fa6a 12339 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 12340 >> (addr_size * 8 - 1)) != 0)
12341 {
91d6fa6a 12342 ent = print_mips_got_entry (data, pltgot, ent);
2b692964 12343 printf (_(" Module pointer (GNU extension)\n"));
ccb4c951
RS		 12344 }
12345 printf ("\n");
12346
91d6fa6a 12347 if (ent < local_end)
ccb4c951
RS		 12348 {
12349 printf (_(" Local entries:\n"));
cc5914eb 12350 printf (" %*s %10s %*s\n",
2b692964
NC		 12351 addr_size * 2, _("Address"), _("Access"),
12352 addr_size * 2, _("Initial"));
91d6fa6a 12353 while (ent < local_end)
ccb4c951 12354 {
91d6fa6a 12355 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12356 printf ("\n");
12357 }
12358 printf ("\n");
12359 }
12360
12361 if (gotsym < symtabno)
12362 {
12363 int sym_width;
12364
12365 printf (_(" Global entries:\n"));
cc5914eb 12366 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 12367 addr_size * 2, _("Address"),
12368 _("Access"),
2b692964 12369 addr_size * 2, _("Initial"),
9cf03b7e
NC		 12370 addr_size * 2, _("Sym.Val."),
12371 _("Type"),
12372 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12373 _("Ndx"), _("Name"));
12374
ccb4c951
RS		 12375 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12376 for (i = gotsym; i < symtabno; i++)
12377 {
2cf0635d 12378 Elf_Internal_Sym * psym;
ccb4c951
RS		 12379
12380 psym = dynamic_symbols + i;
91d6fa6a 12381 ent = print_mips_got_entry (data, pltgot, ent);
ccb4c951
RS		 12382 printf (" ");
12383 print_vma (psym->st_value, LONG_HEX);
12384 printf (" %-7s %3s ",
12385 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12386 get_symbol_index_type (psym->st_shndx));
12387 if (VALID_DYNAMIC_NAME (psym->st_name))
12388 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12389 else
2b692964 12390 printf (_("<corrupt: %14ld>"), psym->st_name);
ccb4c951
RS		 12391 printf ("\n");
12392 }
12393 printf ("\n");
12394 }
12395
12396 if (data)
12397 free (data);
12398 }
12399
861fb55a
DJ		 12400 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12401 {
91d6fa6a 12402 bfd_vma ent, end;
861fb55a
DJ		 12403 size_t offset, rel_offset;
12404 unsigned long count, i;
2cf0635d 12405 unsigned char * data;
861fb55a 12406 int addr_size, sym_width;
2cf0635d 12407 Elf_Internal_Rela * rels;
861fb55a
DJ		 12408
12409 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12410 if (pltrel == DT_RELA)
12411 {
12412 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12413 return 0;
12414 }
12415 else
12416 {
12417 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12418 return 0;
12419 }
12420
91d6fa6a 12421 ent = mips_pltgot;
861fb55a
DJ		 12422 addr_size = (is_32bit_elf ? 4 : 8);
12423 end = mips_pltgot + (2 + count) * addr_size;
12424
12425 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 12426 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 12427 1, _("Procedure Linkage Table data"));
59245841
NC		 12428 if (data == NULL)
12429 return 0;
12430
9cf03b7e 12431 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 12432 printf (_(" Reserved entries:\n"));
12433 printf (_(" %*s %*s Purpose\n"),
2b692964 12434 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 12435 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12436 printf (_(" PLT lazy resolver\n"));
91d6fa6a 12437 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 12438 printf (_(" Module pointer\n"));
861fb55a
DJ		 12439 printf ("\n");
12440
12441 printf (_(" Entries:\n"));
cc5914eb 12442 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 12443 addr_size * 2, _("Address"),
12444 addr_size * 2, _("Initial"),
12445 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 12446 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12447 for (i = 0; i < count; i++)
12448 {
2cf0635d 12449 Elf_Internal_Sym * psym;
861fb55a
DJ		 12450
12451 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
91d6fa6a 12452 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a
DJ		 12453 printf (" ");
12454 print_vma (psym->st_value, LONG_HEX);
12455 printf (" %-7s %3s ",
12456 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12457 get_symbol_index_type (psym->st_shndx));
12458 if (VALID_DYNAMIC_NAME (psym->st_name))
12459 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12460 else
2b692964 12461 printf (_("<corrupt: %14ld>"), psym->st_name);
861fb55a
DJ		 12462 printf ("\n");
12463 }
12464 printf ("\n");
12465
12466 if (data)
12467 free (data);
12468 free (rels);
12469 }
12470
252b5132
RH		 12471 return 1;
12472}
12473
047b2264 12474static int
2cf0635d 12475process_gnu_liblist (FILE * file)
047b2264 12476{
2cf0635d
NC		 12477 Elf_Internal_Shdr * section;
12478 Elf_Internal_Shdr * string_sec;
12479 Elf32_External_Lib * elib;
12480 char * strtab;
c256ffe7 12481 size_t strtab_size;
047b2264
JJ		 12482 size_t cnt;
12483 unsigned i;
12484
12485 if (! do_arch)
12486 return 0;
12487
12488 for (i = 0, section = section_headers;
12489 i < elf_header.e_shnum;
b34976b6 12490 i++, section++)
047b2264
JJ		 12491 {
12492 switch (section->sh_type)
12493 {
12494 case SHT_GNU_LIBLIST:
4fbb74a6 12495 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 12496 break;
12497
3f5e193b
NC		 12498 elib = (Elf32_External_Lib *)
12499 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 12500 _("liblist section data"));
047b2264
JJ		 12501
12502 if (elib == NULL)
12503 break;
4fbb74a6 12504 string_sec = section_headers + section->sh_link;
047b2264 12505
3f5e193b
NC		 12506 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12507 string_sec->sh_size,
12508 _("liblist string table"));
047b2264
JJ		 12509 if (strtab == NULL
12510 || section->sh_entsize != sizeof (Elf32_External_Lib))
12511 {
12512 free (elib);
2842702f 12513 free (strtab);
047b2264
JJ		 12514 break;
12515 }
59245841 12516 strtab_size = string_sec->sh_size;
047b2264
JJ		 12517
12518 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12519 SECTION_NAME (section),
0af1713e 12520 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 12521
2b692964 12522 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 12523
12524 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12525 ++cnt)
12526 {
12527 Elf32_Lib liblist;
91d6fa6a 12528 time_t atime;
047b2264 12529 char timebuf[20];
2cf0635d 12530 struct tm * tmp;
047b2264
JJ		 12531
12532 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 12533 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 12534 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12535 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12536 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12537
91d6fa6a 12538 tmp = gmtime (&atime);
e9e44622
JJ		 12539 snprintf (timebuf, sizeof (timebuf),
12540 "%04u-%02u-%02uT%02u:%02u:%02u",
12541 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12542 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 12543
12544 printf ("%3lu: ", (unsigned long) cnt);
12545 if (do_wide)
c256ffe7 12546 printf ("%-20s", liblist.l_name < strtab_size
2b692964 12547 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 12548 else
c256ffe7 12549 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 12550 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 12551 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12552 liblist.l_version, liblist.l_flags);
12553 }
12554
12555 free (elib);
2842702f 12556 free (strtab);
047b2264
JJ		 12557 }
12558 }
12559
12560 return 1;
12561}
12562
9437c45b 12563static const char *
d3ba0551 12564get_note_type (unsigned e_type)
779fe533
NC		 12565{
12566 static char buff[64];
103f02d3 12567
1ec5cd37
NC		 12568 if (elf_header.e_type == ET_CORE)
12569 switch (e_type)
12570 {
57346661 12571 case NT_AUXV:
1ec5cd37 12572 return _("NT_AUXV (auxiliary vector)");
57346661 12573 case NT_PRSTATUS:
1ec5cd37 12574 return _("NT_PRSTATUS (prstatus structure)");
57346661 12575 case NT_FPREGSET:
1ec5cd37 12576 return _("NT_FPREGSET (floating point registers)");
57346661 12577 case NT_PRPSINFO:
1ec5cd37 12578 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 12579 case NT_TASKSTRUCT:
1ec5cd37 12580 return _("NT_TASKSTRUCT (task structure)");
57346661 12581 case NT_PRXFPREG:
1ec5cd37 12582 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 12583 case NT_PPC_VMX:
12584 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 12585 case NT_PPC_VSX:
12586 return _("NT_PPC_VSX (ppc VSX registers)");
4339cae0
L		 12587 case NT_X86_XSTATE:
12588 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 12589 case NT_S390_HIGH_GPRS:
12590 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 12591 case NT_S390_TIMER:
12592 return _("NT_S390_TIMER (s390 timer register)");
12593 case NT_S390_TODCMP:
12594 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12595 case NT_S390_TODPREG:
12596 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12597 case NT_S390_CTRS:
12598 return _("NT_S390_CTRS (s390 control registers)");
12599 case NT_S390_PREFIX:
12600 return _("NT_S390_PREFIX (s390 prefix register)");
faa9a424
UW		 12601 case NT_ARM_VFP:
12602 return _("NT_ARM_VFP (arm VFP registers)");
57346661 12603 case NT_PSTATUS:
1ec5cd37 12604 return _("NT_PSTATUS (pstatus structure)");
57346661 12605 case NT_FPREGS:
1ec5cd37 12606 return _("NT_FPREGS (floating point registers)");
57346661 12607 case NT_PSINFO:
1ec5cd37 12608 return _("NT_PSINFO (psinfo structure)");
57346661 12609 case NT_LWPSTATUS:
1ec5cd37 12610 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 12611 case NT_LWPSINFO:
1ec5cd37 12612 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 12613 case NT_WIN32PSTATUS:
1ec5cd37 12614 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 12615 case NT_SIGINFO:
12616 return _("NT_SIGINFO (siginfo_t data)");
12617 case NT_FILE:
12618 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 12619 default:
12620 break;
12621 }
12622 else
12623 switch (e_type)
12624 {
12625 case NT_VERSION:
12626 return _("NT_VERSION (version)");
12627 case NT_ARCH:
12628 return _("NT_ARCH (architecture)");
12629 default:
12630 break;
12631 }
12632
e9e44622 12633 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 12634 return buff;
779fe533
NC		 12635}
12636
9ece1fa9
TT		 12637static int
12638print_core_note (Elf_Internal_Note *pnote)
12639{
12640 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12641 bfd_vma count, page_size;
12642 unsigned char *descdata, *filenames, *descend;
12643
12644 if (pnote->type != NT_FILE)
12645 return 1;
12646
12647#ifndef BFD64
12648 if (!is_32bit_elf)
12649 {
12650 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12651 /* Still "successful". */
12652 return 1;
12653 }
12654#endif
12655
12656 if (pnote->descsz < 2 * addr_size)
12657 {
12658 printf (_(" Malformed note - too short for header\n"));
12659 return 0;
12660 }
12661
12662 descdata = (unsigned char *) pnote->descdata;
12663 descend = descdata + pnote->descsz;
12664
12665 if (descdata[pnote->descsz - 1] != '\0')
12666 {
12667 printf (_(" Malformed note - does not end with \\0\n"));
12668 return 0;
12669 }
12670
12671 count = byte_get (descdata, addr_size);
12672 descdata += addr_size;
12673
12674 page_size = byte_get (descdata, addr_size);
12675 descdata += addr_size;
12676
12677 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12678 {
12679 printf (_(" Malformed note - too short for supplied file count\n"));
12680 return 0;
12681 }
12682
12683 printf (_(" Page size: "));
12684 print_vma (page_size, DEC);
12685 printf ("\n");
12686
12687 printf (_(" %*s%*s%*s\n"),
12688 (int) (2 + 2 * addr_size), _("Start"),
12689 (int) (4 + 2 * addr_size), _("End"),
12690 (int) (4 + 2 * addr_size), _("Page Offset"));
12691 filenames = descdata + count * 3 * addr_size;
12692 while (--count > 0)
12693 {
12694 bfd_vma start, end, file_ofs;
12695
12696 if (filenames == descend)
12697 {
12698 printf (_(" Malformed note - filenames end too early\n"));
12699 return 0;
12700 }
12701
12702 start = byte_get (descdata, addr_size);
12703 descdata += addr_size;
12704 end = byte_get (descdata, addr_size);
12705 descdata += addr_size;
12706 file_ofs = byte_get (descdata, addr_size);
12707 descdata += addr_size;
12708
12709 printf (" ");
12710 print_vma (start, FULL_HEX);
12711 printf (" ");
12712 print_vma (end, FULL_HEX);
12713 printf (" ");
12714 print_vma (file_ofs, FULL_HEX);
12715 printf ("\n %s\n", filenames);
12716
12717 filenames += 1 + strlen ((char *) filenames);
12718 }
12719
12720 return 1;
12721}
12722
1118d252
RM		 12723static const char *
12724get_gnu_elf_note_type (unsigned e_type)
12725{
12726 static char buff[64];
12727
12728 switch (e_type)
12729 {
12730 case NT_GNU_ABI_TAG:
12731 return _("NT_GNU_ABI_TAG (ABI version tag)");
12732 case NT_GNU_HWCAP:
12733 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12734 case NT_GNU_BUILD_ID:
12735 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 12736 case NT_GNU_GOLD_VERSION:
12737 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 12738 default:
12739 break;
12740 }
12741
12742 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12743 return buff;
12744}
12745
664f90a3
TT		 12746static int
12747print_gnu_note (Elf_Internal_Note *pnote)
12748{
12749 switch (pnote->type)
12750 {
12751 case NT_GNU_BUILD_ID:
12752 {
12753 unsigned long i;
12754
12755 printf (_(" Build ID: "));
12756 for (i = 0; i < pnote->descsz; ++i)
12757 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 12758 printf ("\n");
664f90a3
TT		 12759 }
12760 break;
12761
12762 case NT_GNU_ABI_TAG:
12763 {
12764 unsigned long os, major, minor, subminor;
12765 const char *osname;
12766
12767 os = byte_get ((unsigned char *) pnote->descdata, 4);
12768 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12769 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12770 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12771
12772 switch (os)
12773 {
12774 case GNU_ABI_TAG_LINUX:
12775 osname = "Linux";
12776 break;
12777 case GNU_ABI_TAG_HURD:
12778 osname = "Hurd";
12779 break;
12780 case GNU_ABI_TAG_SOLARIS:
12781 osname = "Solaris";
12782 break;
12783 case GNU_ABI_TAG_FREEBSD:
12784 osname = "FreeBSD";
12785 break;
12786 case GNU_ABI_TAG_NETBSD:
12787 osname = "NetBSD";
12788 break;
12789 default:
12790 osname = "Unknown";
12791 break;
12792 }
12793
12794 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12795 major, minor, subminor);
12796 }
12797 break;
12798 }
12799
12800 return 1;
12801}
12802
9437c45b 12803static const char *
d3ba0551 12804get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 12805{
12806 static char buff[64];
12807
b4db1224 12808 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 12809 {
12810 /* NetBSD core "procinfo" structure. */
12811 return _("NetBSD procinfo structure");
12812 }
12813
12814 /* As of Jan 2002 there are no other machine-independent notes
12815 defined for NetBSD core files. If the note type is less
12816 than the start of the machine-dependent note types, we don't
12817 understand it. */
12818
b4db1224 12819 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 12820 {
e9e44622 12821 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 12822 return buff;
12823 }
12824
12825 switch (elf_header.e_machine)
12826 {
12827 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12828 and PT_GETFPREGS == mach+2. */
12829
12830 case EM_OLD_ALPHA:
12831 case EM_ALPHA:
12832 case EM_SPARC:
12833 case EM_SPARC32PLUS:
12834 case EM_SPARCV9:
12835 switch (e_type)
12836 {
2b692964 12837 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 12838 return _("PT_GETREGS (reg structure)");
2b692964 12839 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 12840 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12841 default:
12842 break;
12843 }
12844 break;
12845
12846 /* On all other arch's, PT_GETREGS == mach+1 and
12847 PT_GETFPREGS == mach+3. */
12848 default:
12849 switch (e_type)
12850 {
2b692964 12851 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 12852 return _("PT_GETREGS (reg structure)");
2b692964 12853 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 12854 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 12855 default:
12856 break;
12857 }
12858 }
12859
9cf03b7e 12860 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 12861 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 12862 return buff;
12863}
12864
70616151
TT		 12865static const char *
12866get_stapsdt_note_type (unsigned e_type)
12867{
12868 static char buff[64];
12869
12870 switch (e_type)
12871 {
12872 case NT_STAPSDT:
12873 return _("NT_STAPSDT (SystemTap probe descriptors)");
12874
12875 default:
12876 break;
12877 }
12878
12879 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12880 return buff;
12881}
12882
c6a9fc58
TT		 12883static int
12884print_stapsdt_note (Elf_Internal_Note *pnote)
12885{
12886 int addr_size = is_32bit_elf ? 4 : 8;
12887 char *data = pnote->descdata;
12888 char *data_end = pnote->descdata + pnote->descsz;
12889 bfd_vma pc, base_addr, semaphore;
12890 char *provider, *probe, *arg_fmt;
12891
12892 pc = byte_get ((unsigned char *) data, addr_size);
12893 data += addr_size;
12894 base_addr = byte_get ((unsigned char *) data, addr_size);
12895 data += addr_size;
12896 semaphore = byte_get ((unsigned char *) data, addr_size);
12897 data += addr_size;
12898
12899 provider = data;
12900 data += strlen (data) + 1;
12901 probe = data;
12902 data += strlen (data) + 1;
12903 arg_fmt = data;
12904 data += strlen (data) + 1;
12905
12906 printf (_(" Provider: %s\n"), provider);
12907 printf (_(" Name: %s\n"), probe);
12908 printf (_(" Location: "));
12909 print_vma (pc, FULL_HEX);
12910 printf (_(", Base: "));
12911 print_vma (base_addr, FULL_HEX);
12912 printf (_(", Semaphore: "));
12913 print_vma (semaphore, FULL_HEX);
9cf03b7e 12914 printf ("\n");
c6a9fc58
TT		 12915 printf (_(" Arguments: %s\n"), arg_fmt);
12916
12917 return data == data_end;
12918}
12919
00e98fc7
TG		 12920static const char *
12921get_ia64_vms_note_type (unsigned e_type)
12922{
12923 static char buff[64];
12924
12925 switch (e_type)
12926 {
12927 case NT_VMS_MHD:
12928 return _("NT_VMS_MHD (module header)");
12929 case NT_VMS_LNM:
12930 return _("NT_VMS_LNM (language name)");
12931 case NT_VMS_SRC:
12932 return _("NT_VMS_SRC (source files)");
12933 case NT_VMS_TITLE:
9cf03b7e 12934 return "NT_VMS_TITLE";
00e98fc7
TG		 12935 case NT_VMS_EIDC:
12936 return _("NT_VMS_EIDC (consistency check)");
12937 case NT_VMS_FPMODE:
12938 return _("NT_VMS_FPMODE (FP mode)");
12939 case NT_VMS_LINKTIME:
9cf03b7e 12940 return "NT_VMS_LINKTIME";
00e98fc7
TG		 12941 case NT_VMS_IMGNAM:
12942 return _("NT_VMS_IMGNAM (image name)");
12943 case NT_VMS_IMGID:
12944 return _("NT_VMS_IMGID (image id)");
12945 case NT_VMS_LINKID:
12946 return _("NT_VMS_LINKID (link id)");
12947 case NT_VMS_IMGBID:
12948 return _("NT_VMS_IMGBID (build id)");
12949 case NT_VMS_GSTNAM:
12950 return _("NT_VMS_GSTNAM (sym table name)");
12951 case NT_VMS_ORIG_DYN:
9cf03b7e 12952 return "NT_VMS_ORIG_DYN";
00e98fc7 12953 case NT_VMS_PATCHTIME:
9cf03b7e 12954 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 12955 default:
12956 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12957 return buff;
12958 }
12959}
12960
12961static int
12962print_ia64_vms_note (Elf_Internal_Note * pnote)
12963{
12964 switch (pnote->type)
12965 {
12966 case NT_VMS_MHD:
12967 if (pnote->descsz > 36)
12968 {
12969 size_t l = strlen (pnote->descdata + 34);
12970 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12971 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12972 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12973 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12974 }
12975 else
12976 printf (_(" Invalid size\n"));
12977 break;
12978 case NT_VMS_LNM:
12979 printf (_(" Language: %s\n"), pnote->descdata);
12980 break;
12981#ifdef BFD64
12982 case NT_VMS_FPMODE:
9cf03b7e 12983 printf (_(" Floating Point mode: "));
4a5cb34f 12984 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 12985 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12986 break;
12987 case NT_VMS_LINKTIME:
12988 printf (_(" Link time: "));
12989 print_vms_time
12990 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12991 printf ("\n");
12992 break;
12993 case NT_VMS_PATCHTIME:
12994 printf (_(" Patch time: "));
12995 print_vms_time
12996 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12997 printf ("\n");
12998 break;
12999 case NT_VMS_ORIG_DYN:
13000 printf (_(" Major id: %u, minor id: %u\n"),
13001 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13002 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 13003 printf (_(" Last modified : "));
00e98fc7
TG		 13004 print_vms_time
13005 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 13006 printf (_("\n Link flags : "));
4a5cb34f 13007 printf ("0x%016" BFD_VMA_FMT "x\n",
00e98fc7
TG		 13008 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13009 printf (_(" Header flags: 0x%08x\n"),
13010 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13011 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13012 break;
13013#endif
13014 case NT_VMS_IMGNAM:
13015 printf (_(" Image name: %s\n"), pnote->descdata);
13016 break;
13017 case NT_VMS_GSTNAM:
13018 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13019 break;
13020 case NT_VMS_IMGID:
13021 printf (_(" Image id: %s\n"), pnote->descdata);
13022 break;
13023 case NT_VMS_LINKID:
13024 printf (_(" Linker id: %s\n"), pnote->descdata);
13025 break;
13026 default:
13027 break;
13028 }
13029 return 1;
13030}
13031
6d118b09
NC		 13032/* Note that by the ELF standard, the name field is already null byte
13033 terminated, and namesz includes the terminating null byte.
13034 I.E. the value of namesz for the name "FSF" is 4.
13035
e3c8793a 13036 If the value of namesz is zero, there is no name present. */
779fe533 13037static int
2cf0635d 13038process_note (Elf_Internal_Note * pnote)
779fe533 13039{
2cf0635d
NC		 13040 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13041 const char * nt;
9437c45b
JT		 13042
13043 if (pnote->namesz == 0)
1ec5cd37
NC		 13044 /* If there is no note name, then use the default set of
13045 note type strings. */
13046 nt = get_note_type (pnote->type);
13047
1118d252
RM		 13048 else if (const_strneq (pnote->namedata, "GNU"))
13049 /* GNU-specific object file notes. */
13050 nt = get_gnu_elf_note_type (pnote->type);
13051
0112cd26 13052 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 13053 /* NetBSD-specific core file notes. */
13054 nt = get_netbsd_elfcore_note_type (pnote->type);
13055
b15fa79e
AM		 13056 else if (strneq (pnote->namedata, "SPU/", 4))
13057 {
13058 /* SPU-specific core file notes. */
13059 nt = pnote->namedata + 4;
13060 name = "SPU";
13061 }
13062
00e98fc7
TG		 13063 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13064 /* VMS/ia64-specific file notes. */
13065 nt = get_ia64_vms_note_type (pnote->type);
13066
70616151
TT		 13067 else if (const_strneq (pnote->namedata, "stapsdt"))
13068 nt = get_stapsdt_note_type (pnote->type);
13069
9437c45b 13070 else
1ec5cd37
NC		 13071 /* Don't recognize this note name; just use the default set of
13072 note type strings. */
00e98fc7 13073 nt = get_note_type (pnote->type);
9437c45b 13074
2aee03ae 13075 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 13076
13077 if (const_strneq (pnote->namedata, "IPF/VMS"))
13078 return print_ia64_vms_note (pnote);
664f90a3
TT		 13079 else if (const_strneq (pnote->namedata, "GNU"))
13080 return print_gnu_note (pnote);
c6a9fc58
TT		 13081 else if (const_strneq (pnote->namedata, "stapsdt"))
13082 return print_stapsdt_note (pnote);
9ece1fa9
TT		 13083 else if (const_strneq (pnote->namedata, "CORE"))
13084 return print_core_note (pnote);
00e98fc7
TG		 13085 else
13086 return 1;
779fe533
NC		 13087}
13088
6d118b09 13089
779fe533 13090static int
2cf0635d 13091process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 13092{
2cf0635d
NC		 13093 Elf_External_Note * pnotes;
13094 Elf_External_Note * external;
b34976b6 13095 int res = 1;
103f02d3 13096
779fe533
NC		 13097 if (length <= 0)
13098 return 0;
103f02d3 13099
3f5e193b
NC		 13100 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13101 _("notes"));
dd24e3da 13102 if (pnotes == NULL)
a6e9f9df 13103 return 0;
779fe533 13104
103f02d3 13105 external = pnotes;
103f02d3 13106
305c7206 13107 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 13108 (unsigned long) offset, (unsigned long) length);
2aee03ae 13109 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 13110
2cf0635d 13111 while (external < (Elf_External_Note *) ((char *) pnotes + length))
779fe533 13112 {
2cf0635d 13113 Elf_External_Note * next;
b34976b6 13114 Elf_Internal_Note inote;
2cf0635d 13115 char * temp = NULL;
6d118b09 13116
00e98fc7
TG		 13117 if (!is_ia64_vms ())
13118 {
13119 inote.type = BYTE_GET (external->type);
13120 inote.namesz = BYTE_GET (external->namesz);
13121 inote.namedata = external->name;
13122 inote.descsz = BYTE_GET (external->descsz);
13123 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13124 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13125
13126 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13127 }
13128 else
13129 {
13130 Elf64_External_VMS_Note *vms_external;
13131
13132 vms_external = (Elf64_External_VMS_Note *)external;
13133 inote.type = BYTE_GET (vms_external->type);
13134 inote.namesz = BYTE_GET (vms_external->namesz);
13135 inote.namedata = vms_external->name;
13136 inote.descsz = BYTE_GET (vms_external->descsz);
13137 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13138 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13139
13140 next = (Elf_External_Note *)
13141 (inote.descdata + align_power (inote.descsz, 3));
13142 }
3e55a963 13143
dd24e3da
NC		 13144 if ( ((char *) next > ((char *) pnotes) + length)
13145 || ((char *) next < (char *) pnotes))
3e55a963 13146 {
0fd3a477 13147 warn (_("corrupt note found at offset %lx into core notes\n"),
0af1713e 13148 (unsigned long) ((char *) external - (char *) pnotes));
0fd3a477 13149 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
3e55a963
NC		 13150 inote.type, inote.namesz, inote.descsz);
13151 break;
13152 }
13153
13154 external = next;
6d118b09 13155
dd24e3da 13156 /* Prevent out-of-bounds indexing. */
8b971f9f 13157 if (inote.namedata + inote.namesz > (char *) pnotes + length
dd24e3da
NC		 13158 || inote.namedata + inote.namesz < inote.namedata)
13159 {
13160 warn (_("corrupt note found at offset %lx into core notes\n"),
13161 (unsigned long) ((char *) external - (char *) pnotes));
13162 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13163 inote.type, inote.namesz, inote.descsz);
13164 break;
13165 }
13166
6d118b09
NC		 13167 /* Verify that name is null terminated. It appears that at least
13168 one version of Linux (RedHat 6.0) generates corefiles that don't
13169 comply with the ELF spec by failing to include the null byte in
13170 namesz. */
8b971f9f 13171 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 13172 {
3f5e193b 13173 temp = (char *) malloc (inote.namesz + 1);
76da6bbe 13174
6d118b09
NC		 13175 if (temp == NULL)
13176 {
13177 error (_("Out of memory\n"));
13178 res = 0;
13179 break;
13180 }
76da6bbe 13181
6d118b09
NC		 13182 strncpy (temp, inote.namedata, inote.namesz);
13183 temp[inote.namesz] = 0;
76da6bbe 13184
6d118b09
NC		 13185 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13186 inote.namedata = temp;
13187 }
13188
13189 res &= process_note (& inote);
103f02d3 13190
6d118b09
NC		 13191 if (temp != NULL)
13192 {
13193 free (temp);
13194 temp = NULL;
13195 }
779fe533
NC		 13196 }
13197
13198 free (pnotes);
103f02d3 13199
779fe533
NC		 13200 return res;
13201}
13202
13203static int
2cf0635d 13204process_corefile_note_segments (FILE * file)
779fe533 13205{
2cf0635d 13206 Elf_Internal_Phdr * segment;
b34976b6
AM		 13207 unsigned int i;
13208 int res = 1;
103f02d3 13209
d93f0186 13210 if (! get_program_headers (file))
779fe533 13211 return 0;
103f02d3 13212
779fe533
NC		 13213 for (i = 0, segment = program_headers;
13214 i < elf_header.e_phnum;
b34976b6 13215 i++, segment++)
779fe533
NC		 13216 {
13217 if (segment->p_type == PT_NOTE)
103f02d3 13218 res &= process_corefile_note_segment (file,
30800947
NC		 13219 (bfd_vma) segment->p_offset,
13220 (bfd_vma) segment->p_filesz);
779fe533 13221 }
103f02d3 13222
779fe533
NC		 13223 return res;
13224}
13225
13226static int
2cf0635d 13227process_note_sections (FILE * file)
1ec5cd37 13228{
2cf0635d 13229 Elf_Internal_Shdr * section;
1ec5cd37
NC		 13230 unsigned long i;
13231 int res = 1;
13232
13233 for (i = 0, section = section_headers;
fa1908fd 13234 i < elf_header.e_shnum && section != NULL;
1ec5cd37
NC		 13235 i++, section++)
13236 if (section->sh_type == SHT_NOTE)
13237 res &= process_corefile_note_segment (file,
13238 (bfd_vma) section->sh_offset,
13239 (bfd_vma) section->sh_size);
13240
13241 return res;
13242}
13243
13244static int
2cf0635d 13245process_notes (FILE * file)
779fe533
NC		 13246{
13247 /* If we have not been asked to display the notes then do nothing. */
13248 if (! do_notes)
13249 return 1;
103f02d3 13250
779fe533 13251 if (elf_header.e_type != ET_CORE)
1ec5cd37 13252 return process_note_sections (file);
103f02d3 13253
779fe533 13254 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 13255 if (elf_header.e_phnum > 0)
13256 return process_corefile_note_segments (file);
779fe533 13257
1ec5cd37
NC		 13258 printf (_("No note segments present in the core file.\n"));
13259 return 1;
779fe533
NC		 13260}
13261
252b5132 13262static int
2cf0635d 13263process_arch_specific (FILE * file)
252b5132 13264{
a952a375
NC		 13265 if (! do_arch)
13266 return 1;
13267
252b5132
RH		 13268 switch (elf_header.e_machine)
13269 {
11c1ff18
PB		 13270 case EM_ARM:
13271 return process_arm_specific (file);
252b5132 13272 case EM_MIPS:
4fe85591 13273 case EM_MIPS_RS3_LE:
252b5132
RH		 13274 return process_mips_specific (file);
13275 break;
34c8bcba
JM		 13276 case EM_PPC:
13277 return process_power_specific (file);
13278 break;
9e8c70f9
DM		 13279 case EM_SPARC:
13280 case EM_SPARC32PLUS:
13281 case EM_SPARCV9:
13282 return process_sparc_specific (file);
13283 break;
59e6276b
JM		 13284 case EM_TI_C6000:
13285 return process_tic6x_specific (file);
13286 break;
252b5132
RH		 13287 default:
13288 break;
13289 }
13290 return 1;
13291}
13292
13293static int
2cf0635d 13294get_file_header (FILE * file)
252b5132 13295{
9ea033b2
NC		 13296 /* Read in the identity array. */
13297 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 13298 return 0;
13299
9ea033b2 13300 /* Determine how to read the rest of the header. */
b34976b6 13301 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 13302 {
13303 default: /* fall through */
13304 case ELFDATANONE: /* fall through */
adab8cdc
AO		 13305 case ELFDATA2LSB:
13306 byte_get = byte_get_little_endian;
13307 byte_put = byte_put_little_endian;
13308 break;
13309 case ELFDATA2MSB:
13310 byte_get = byte_get_big_endian;
13311 byte_put = byte_put_big_endian;
13312 break;
9ea033b2
NC		 13313 }
13314
13315 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 13316 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 13317
13318 /* Read in the rest of the header. */
13319 if (is_32bit_elf)
13320 {
13321 Elf32_External_Ehdr ehdr32;
252b5132 13322
9ea033b2
NC		 13323 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13324 return 0;
103f02d3 13325
9ea033b2
NC		 13326 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13327 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13328 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13329 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13330 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13331 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13332 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13333 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13334 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13335 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13336 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13337 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13338 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13339 }
252b5132 13340 else
9ea033b2
NC		 13341 {
13342 Elf64_External_Ehdr ehdr64;
a952a375
NC		 13343
13344 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13345 we will not be able to cope with the 64bit data found in
13346 64 ELF files. Detect this now and abort before we start
50c2245b 13347 overwriting things. */
a952a375
NC		 13348 if (sizeof (bfd_vma) < 8)
13349 {
e3c8793a
NC		 13350 error (_("This instance of readelf has been built without support for a\n\
1335164 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 13352 return 0;
13353 }
103f02d3 13354
9ea033b2
NC		 13355 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13356 return 0;
103f02d3 13357
9ea033b2
NC		 13358 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13359 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13360 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 13361 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13362 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13363 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 13364 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13365 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13366 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13367 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13368 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13369 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13370 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13371 }
252b5132 13372
7ece0d85
JJ		 13373 if (elf_header.e_shoff)
13374 {
13375 /* There may be some extensions in the first section header. Don't
13376 bomb if we can't read it. */
13377 if (is_32bit_elf)
13378 get_32bit_section_headers (file, 1);
13379 else
13380 get_64bit_section_headers (file, 1);
13381 }
560f3c1c 13382
252b5132
RH		 13383 return 1;
13384}
13385
fb52b2f4
NC		 13386/* Process one ELF object file according to the command line options.
13387 This file may actually be stored in an archive. The file is
13388 positioned at the start of the ELF object. */
13389
ff78d6d6 13390static int
2cf0635d 13391process_object (char * file_name, FILE * file)
252b5132 13392{
252b5132
RH		 13393 unsigned int i;
13394
252b5132
RH		 13395 if (! get_file_header (file))
13396 {
13397 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 13398 return 1;
252b5132
RH		 13399 }
13400
13401 /* Initialise per file variables. */
60bca95a 13402 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 13403 version_info[i] = 0;
13404
60bca95a 13405 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 13406 dynamic_info[i] = 0;
5115b233 13407 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 13408
13409 /* Process the file. */
13410 if (show_name)
13411 printf (_("\nFile: %s\n"), file_name);
13412
18bd398b
NC		 13413 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13414 Note we do this even if cmdline_dump_sects is empty because we
13415 must make sure that the dump_sets array is zeroed out before each
13416 object file is processed. */
13417 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 13418 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 13419
13420 if (num_cmdline_dump_sects > 0)
13421 {
13422 if (num_dump_sects == 0)
13423 /* A sneaky way of allocating the dump_sects array. */
09c11c86 13424 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 13425
13426 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 13427 memcpy (dump_sects, cmdline_dump_sects,
13428 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 13429 }
d70c5fc7 13430
252b5132 13431 if (! process_file_header ())
fb52b2f4 13432 return 1;
252b5132 13433
d1f5c6e3 13434 if (! process_section_headers (file))
2f62977e 13435 {
d1f5c6e3
L		 13436 /* Without loaded section headers we cannot process lots of
13437 things. */
2f62977e 13438 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 13439
2f62977e 13440 if (! do_using_dynamic)
2c610e4b 13441 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 13442 }
252b5132 13443
d1f5c6e3
L		 13444 if (! process_section_groups (file))
13445 {
13446 /* Without loaded section groups we cannot process unwind. */
13447 do_unwind = 0;
13448 }
13449
2f62977e 13450 if (process_program_headers (file))
b2d38a17 13451 process_dynamic_section (file);
252b5132
RH		 13452
13453 process_relocs (file);
13454
4d6ed7c8
NC		 13455 process_unwind (file);
13456
252b5132
RH		 13457 process_symbol_table (file);
13458
13459 process_syminfo (file);
13460
13461 process_version_sections (file);
13462
13463 process_section_contents (file);
f5842774 13464
1ec5cd37 13465 process_notes (file);
103f02d3 13466
047b2264
JJ		 13467 process_gnu_liblist (file);
13468
252b5132
RH		 13469 process_arch_specific (file);
13470
d93f0186
NC		 13471 if (program_headers)
13472 {
13473 free (program_headers);
13474 program_headers = NULL;
13475 }
13476
252b5132
RH		 13477 if (section_headers)
13478 {
13479 free (section_headers);
13480 section_headers = NULL;
13481 }
13482
13483 if (string_table)
13484 {
13485 free (string_table);
13486 string_table = NULL;
d40ac9bd 13487 string_table_length = 0;
252b5132
RH		 13488 }
13489
13490 if (dynamic_strings)
13491 {
13492 free (dynamic_strings);
13493 dynamic_strings = NULL;
d79b3d50 13494 dynamic_strings_length = 0;
252b5132
RH		 13495 }
13496
13497 if (dynamic_symbols)
13498 {
13499 free (dynamic_symbols);
13500 dynamic_symbols = NULL;
19936277 13501 num_dynamic_syms = 0;
252b5132
RH		 13502 }
13503
13504 if (dynamic_syminfo)
13505 {
13506 free (dynamic_syminfo);
13507 dynamic_syminfo = NULL;
13508 }
ff78d6d6 13509
293c573e
MR		 13510 if (dynamic_section)
13511 {
13512 free (dynamic_section);
13513 dynamic_section = NULL;
13514 }
13515
e4b17d5c
L		 13516 if (section_headers_groups)
13517 {
13518 free (section_headers_groups);
13519 section_headers_groups = NULL;
13520 }
13521
13522 if (section_groups)
13523 {
2cf0635d
NC		 13524 struct group_list * g;
13525 struct group_list * next;
e4b17d5c
L		 13526
13527 for (i = 0; i < group_count; i++)
13528 {
13529 for (g = section_groups [i].root; g != NULL; g = next)
13530 {
13531 next = g->next;
13532 free (g);
13533 }
13534 }
13535
13536 free (section_groups);
13537 section_groups = NULL;
13538 }
13539
19e6b90e 13540 free_debug_memory ();
18bd398b 13541
ff78d6d6 13542 return 0;
252b5132
RH		 13543}
13544
2cf0635d
NC		 13545/* Process an ELF archive.
13546 On entry the file is positioned just after the ARMAG string. */
13547
13548static int
13549process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13550{
13551 struct archive_info arch;
13552 struct archive_info nested_arch;
13553 size_t got;
2cf0635d
NC		 13554 int ret;
13555
13556 show_name = 1;
13557
13558 /* The ARCH structure is used to hold information about this archive. */
13559 arch.file_name = NULL;
13560 arch.file = NULL;
13561 arch.index_array = NULL;
13562 arch.sym_table = NULL;
13563 arch.longnames = NULL;
13564
13565 /* The NESTED_ARCH structure is used as a single-item cache of information
13566 about a nested archive (when members of a thin archive reside within
13567 another regular archive file). */
13568 nested_arch.file_name = NULL;
13569 nested_arch.file = NULL;
13570 nested_arch.index_array = NULL;
13571 nested_arch.sym_table = NULL;
13572 nested_arch.longnames = NULL;
13573
13574 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13575 {
13576 ret = 1;
13577 goto out;
4145f1d5 13578 }
fb52b2f4 13579
4145f1d5
NC		 13580 if (do_archive_index)
13581 {
2cf0635d 13582 if (arch.sym_table == NULL)
4145f1d5
NC		 13583 error (_("%s: unable to dump the index as none was found\n"), file_name);
13584 else
13585 {
2cf0635d 13586 unsigned int i, l;
4145f1d5
NC		 13587 unsigned long current_pos;
13588
13589 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
c2a7d3f5 13590 file_name, (long) arch.index_num, arch.sym_size);
4145f1d5
NC		 13591 current_pos = ftell (file);
13592
2cf0635d 13593 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 13594 {
2cf0635d
NC		 13595 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13596 {
13597 char * member_name;
4145f1d5 13598
2cf0635d
NC		 13599 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13600
13601 if (member_name != NULL)
13602 {
13603 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13604
13605 if (qualified_name != NULL)
13606 {
c2a7d3f5
NC		 13607 printf (_("Contents of binary %s at offset "), qualified_name);
13608 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13609 putchar ('\n');
2cf0635d
NC		 13610 free (qualified_name);
13611 }
4145f1d5
NC		 13612 }
13613 }
2cf0635d
NC		 13614
13615 if (l >= arch.sym_size)
4145f1d5
NC		 13616 {
13617 error (_("%s: end of the symbol table reached before the end of the index\n"),
13618 file_name);
cb8f3167 13619 break;
4145f1d5 13620 }
2cf0635d
NC		 13621 printf ("\t%s\n", arch.sym_table + l);
13622 l += strlen (arch.sym_table + l) + 1;
4145f1d5
NC		 13623 }
13624
c2a7d3f5
NC		 13625 if (arch.uses_64bit_indicies)
13626 l = (l + 7) & ~ 7;
13627 else
13628 l += l & 1;
13629
2cf0635d 13630 if (l < arch.sym_size)
c2a7d3f5
NC		 13631 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13632 file_name, arch.sym_size - l);
4145f1d5 13633
4145f1d5
NC		 13634 if (fseek (file, current_pos, SEEK_SET) != 0)
13635 {
13636 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 13637 ret = 1;
13638 goto out;
4145f1d5 13639 }
fb52b2f4 13640 }
4145f1d5
NC		 13641
13642 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13643 && !do_segments && !do_header && !do_dump && !do_version
13644 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 13645 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 13646 {
13647 ret = 0; /* Archive index only. */
13648 goto out;
13649 }
fb52b2f4
NC		 13650 }
13651
d989285c 13652 ret = 0;
fb52b2f4
NC		 13653
13654 while (1)
13655 {
2cf0635d
NC		 13656 char * name;
13657 size_t namelen;
13658 char * qualified_name;
13659
13660 /* Read the next archive header. */
13661 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13662 {
13663 error (_("%s: failed to seek to next archive header\n"), file_name);
13664 return 1;
13665 }
13666 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13667 if (got != sizeof arch.arhdr)
13668 {
13669 if (got == 0)
13670 break;
13671 error (_("%s: failed to read archive header\n"), file_name);
13672 ret = 1;
13673 break;
13674 }
13675 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13676 {
13677 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13678 ret = 1;
13679 break;
13680 }
13681
13682 arch.next_arhdr_offset += sizeof arch.arhdr;
13683
13684 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13685 if (archive_file_size & 01)
13686 ++archive_file_size;
13687
13688 name = get_archive_member_name (&arch, &nested_arch);
13689 if (name == NULL)
fb52b2f4 13690 {
0fd3a477 13691 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13692 ret = 1;
13693 break;
fb52b2f4 13694 }
2cf0635d 13695 namelen = strlen (name);
fb52b2f4 13696
2cf0635d
NC		 13697 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13698 if (qualified_name == NULL)
fb52b2f4 13699 {
2cf0635d 13700 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 13701 ret = 1;
13702 break;
fb52b2f4
NC		 13703 }
13704
2cf0635d
NC		 13705 if (is_thin_archive && arch.nested_member_origin == 0)
13706 {
13707 /* This is a proxy for an external member of a thin archive. */
13708 FILE * member_file;
13709 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13710 if (member_file_name == NULL)
13711 {
13712 ret = 1;
13713 break;
13714 }
13715
13716 member_file = fopen (member_file_name, "rb");
13717 if (member_file == NULL)
13718 {
13719 error (_("Input file '%s' is not readable.\n"), member_file_name);
13720 free (member_file_name);
13721 ret = 1;
13722 break;
13723 }
13724
13725 archive_file_offset = arch.nested_member_origin;
13726
13727 ret |= process_object (qualified_name, member_file);
13728
13729 fclose (member_file);
13730 free (member_file_name);
13731 }
13732 else if (is_thin_archive)
13733 {
13734 /* This is a proxy for a member of a nested archive. */
13735 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13736
13737 /* The nested archive file will have been opened and setup by
13738 get_archive_member_name. */
13739 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13740 {
13741 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13742 ret = 1;
13743 break;
13744 }
13745
13746 ret |= process_object (qualified_name, nested_arch.file);
13747 }
13748 else
13749 {
13750 archive_file_offset = arch.next_arhdr_offset;
13751 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 13752
2cf0635d
NC		 13753 ret |= process_object (qualified_name, file);
13754 }
fb52b2f4 13755
2b52916e
L		 13756 if (dump_sects != NULL)
13757 {
13758 free (dump_sects);
13759 dump_sects = NULL;
13760 num_dump_sects = 0;
13761 }
13762
2cf0635d 13763 free (qualified_name);
fb52b2f4
NC		 13764 }
13765
4145f1d5 13766 out:
2cf0635d
NC		 13767 if (nested_arch.file != NULL)
13768 fclose (nested_arch.file);
13769 release_archive (&nested_arch);
13770 release_archive (&arch);
fb52b2f4 13771
d989285c 13772 return ret;
fb52b2f4
NC		 13773}
13774
13775static int
2cf0635d 13776process_file (char * file_name)
fb52b2f4 13777{
2cf0635d 13778 FILE * file;
fb52b2f4
NC		 13779 struct stat statbuf;
13780 char armag[SARMAG];
13781 int ret;
13782
13783 if (stat (file_name, &statbuf) < 0)
13784 {
f24ddbdd
NC		 13785 if (errno == ENOENT)
13786 error (_("'%s': No such file\n"), file_name);
13787 else
13788 error (_("Could not locate '%s'. System error message: %s\n"),
13789 file_name, strerror (errno));
13790 return 1;
13791 }
13792
13793 if (! S_ISREG (statbuf.st_mode))
13794 {
13795 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 13796 return 1;
13797 }
13798
13799 file = fopen (file_name, "rb");
13800 if (file == NULL)
13801 {
f24ddbdd 13802 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 13803 return 1;
13804 }
13805
13806 if (fread (armag, SARMAG, 1, file) != 1)
13807 {
4145f1d5 13808 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 13809 fclose (file);
13810 return 1;
13811 }
13812
13813 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 13814 ret = process_archive (file_name, file, FALSE);
13815 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13816 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 13817 else
13818 {
4145f1d5
NC		 13819 if (do_archive_index)
13820 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13821 file_name);
13822
fb52b2f4
NC		 13823 rewind (file);
13824 archive_file_size = archive_file_offset = 0;
13825 ret = process_object (file_name, file);
13826 }
13827
13828 fclose (file);
13829
13830 return ret;
13831}
13832
252b5132
RH		 13833#ifdef SUPPORT_DISASSEMBLY
13834/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 13835 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 13836 symbols. */
252b5132
RH		 13837
13838void
2cf0635d 13839print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 13840{
13841 fprintf (outfile,"0x%8.8x", addr);
13842}
13843
e3c8793a 13844/* Needed by the i386 disassembler. */
252b5132
RH		 13845void
13846db_task_printsym (unsigned int addr)
13847{
13848 print_address (addr, stderr);
13849}
13850#endif
13851
13852int
2cf0635d 13853main (int argc, char ** argv)
252b5132 13854{
ff78d6d6
L		 13855 int err;
13856
252b5132
RH		 13857#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13858 setlocale (LC_MESSAGES, "");
3882b010
L		 13859#endif
13860#if defined (HAVE_SETLOCALE)
13861 setlocale (LC_CTYPE, "");
252b5132
RH		 13862#endif
13863 bindtextdomain (PACKAGE, LOCALEDIR);
13864 textdomain (PACKAGE);
13865
869b9d07
MM		 13866 expandargv (&argc, &argv);
13867
252b5132
RH		 13868 parse_args (argc, argv);
13869
18bd398b 13870 if (num_dump_sects > 0)
59f14fc0 13871 {
18bd398b 13872 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 13873 cmdline_dump_sects = (dump_type *)
13874 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 13875 if (cmdline_dump_sects == NULL)
591a748a 13876 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 13877 else
13878 {
09c11c86
NC		 13879 memcpy (cmdline_dump_sects, dump_sects,
13880 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 13881 num_cmdline_dump_sects = num_dump_sects;
13882 }
13883 }
13884
18bd398b
NC		 13885 if (optind < (argc - 1))
13886 show_name = 1;
13887
ff78d6d6 13888 err = 0;
252b5132 13889 while (optind < argc)
18bd398b 13890 err |= process_file (argv[optind++]);
252b5132
RH		 13891
13892 if (dump_sects != NULL)
13893 free (dump_sects);
59f14fc0
AS		 13894 if (cmdline_dump_sects != NULL)
13895 free (cmdline_dump_sects);
252b5132 13896
ff78d6d6 13897 return err;
252b5132 13898}
A mirror of the official binutils-gdb repository