projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[AArch64] Fix ARMv8.1 and ARMv8.2 feature settings.
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
b90efa5b 2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.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"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
6a40cf0c
NC		 167typedef struct elf_section_list
168{
169 Elf_Internal_Shdr * hdr;
170 struct elf_section_list * next;
171} elf_section_list;
172
2cf0635d 173char * program_name = "readelf";
c9c1d674 174static unsigned long archive_file_offset;
85b1c36d 175static unsigned long archive_file_size;
f54498b4 176static bfd_size_type current_file_size;
85b1c36d
BE		 177static unsigned long dynamic_addr;
178static bfd_size_type dynamic_size;
8b73c356 179static size_t dynamic_nent;
2cf0635d 180static char * dynamic_strings;
85b1c36d 181static unsigned long dynamic_strings_length;
2cf0635d 182static char * string_table;
85b1c36d
BE		 183static unsigned long string_table_length;
184static unsigned long num_dynamic_syms;
2cf0635d
NC		 185static Elf_Internal_Sym * dynamic_symbols;
186static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 187static unsigned long dynamic_syminfo_offset;
188static unsigned int dynamic_syminfo_nent;
f8eae8b2 189static char program_interpreter[PATH_MAX];
bb8a0291 190static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 191static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 192static bfd_vma version_info[16];
193static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 194static Elf_Internal_Shdr * section_headers;
195static Elf_Internal_Phdr * program_headers;
196static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 197static elf_section_list * symtab_shndx_list;
85b1c36d
BE		 198static int show_name;
199static int do_dynamic;
200static int do_syms;
2c610e4b 201static int do_dyn_syms;
85b1c36d
BE		 202static int do_reloc;
203static int do_sections;
204static int do_section_groups;
5477e8a0 205static int do_section_details;
85b1c36d
BE		 206static int do_segments;
207static int do_unwind;
208static int do_using_dynamic;
209static int do_header;
210static int do_dump;
211static int do_version;
85b1c36d
BE		 212static int do_histogram;
213static int do_debugging;
85b1c36d
BE		 214static int do_arch;
215static int do_notes;
4145f1d5 216static int do_archive_index;
85b1c36d 217static int is_32bit_elf;
0e602686 218static int decompress_dumps;
252b5132 219
e4b17d5c
L		 220struct group_list
221{
2cf0635d 222 struct group_list * next;
e4b17d5c
L		 223 unsigned int section_index;
224};
225
226struct group
227{
2cf0635d 228 struct group_list * root;
e4b17d5c
L		 229 unsigned int group_index;
230};
231
85b1c36d 232static size_t group_count;
2cf0635d
NC		 233static struct group * section_groups;
234static struct group ** section_headers_groups;
e4b17d5c 235
09c11c86
NC		 236
237/* Flag bits indicating particular types of dump. */
238#define HEX_DUMP (1 << 0) /* The -x command line switch. */
239#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 242#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 243
244typedef unsigned char dump_type;
245
246/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 247struct dump_list_entry
248{
2cf0635d 249 char * name;
09c11c86 250 dump_type type;
2cf0635d 251 struct dump_list_entry * next;
aef1f6d0 252};
2cf0635d 253static struct dump_list_entry * dump_sects_byname;
aef1f6d0 254
09c11c86
NC		 255/* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257static dump_type * cmdline_dump_sects = NULL;
258static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 259
260/* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
09c11c86
NC		 265static dump_type * dump_sects = NULL;
266static unsigned int num_dump_sects = 0;
252b5132 267
252b5132 268
c256ffe7 269/* How to print a vma value. */
843dd992
NC		 270typedef enum print_mode
271{
272 HEX,
273 DEC,
274 DEC_5,
275 UNSIGNED,
276 PREFIX_HEX,
277 FULL_HEX,
278 LONG_HEX
279}
280print_mode;
281
bb4d2ac2
L		 282/* Versioned symbol info. */
283enum versioned_symbol_info
284{
285 symbol_undefined,
286 symbol_hidden,
287 symbol_public
288};
289
290static const char *get_symbol_version_string
291 (FILE *file, int is_dynsym, const char *strtab,
292 unsigned long int strtab_size, unsigned int si,
293 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
294 unsigned short *vna_other);
295
9c19a809
NC		 296#define UNKNOWN -1
297
2b692964
NC		 298#define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 302 : string_table + (X)->sh_name))
252b5132 303
ee42cf8c 304#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 305
ba5cdace
NC		 306#define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 309
d79b3d50
NC		 310#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 314
61865e30
NC		 315#define REMOVE_ARCH_BITS(ADDR) \
316 do \
317 { \
318 if (elf_header.e_machine == EM_ARM) \
319 (ADDR) &= ~1; \
320 } \
321 while (0)
d79b3d50 322\f
c9c1d674
EG		 323/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
59245841
NC		 325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 328 and REASON is not NULL then emit an error message using REASON as part of the
329 context. */
59245841 330
c256ffe7 331static void *
57028622
NC		 332get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
a6e9f9df 334{
2cf0635d 335 void * mvar;
57028622 336 bfd_size_type amt = size * nmemb;
a6e9f9df 337
c256ffe7 338 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 339 return NULL;
340
57028622
NC		 341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type)
345 && ( (bfd_size_type) ((size_t) size) != size
346 || (bfd_size_type) ((size_t) nmemb) != nmemb))
347 {
348 if (reason)
349 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
350 (unsigned long long) nmemb, (unsigned long long) size, reason);
351 return NULL;
352 }
353
354 /* Check for size overflow. */
355 if (amt < nmemb)
356 {
357 if (reason)
358 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
359 (unsigned long long) nmemb, (unsigned long long) size, reason);
360 return NULL;
361 }
362
c9c1d674
EG		 363 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
364 attempting to allocate memory when the read is bound to fail. */
365 if (amt > current_file_size
366 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 367 {
049b0c3a 368 if (reason)
57028622
NC		 369 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
370 (unsigned long long) amt, reason);
a6e9f9df
AM		 371 return NULL;
372 }
373
c9c1d674 374 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 375 {
376 if (reason)
c9c1d674
EG		 377 error (_("Unable to seek to 0x%lx for %s\n"),
378 (unsigned long) archive_file_offset + offset, reason);
071436c6
NC		 379 return NULL;
380 }
381
a6e9f9df
AM		 382 mvar = var;
383 if (mvar == NULL)
384 {
c256ffe7 385 /* Check for overflow. */
57028622 386 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 387 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 388 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 389
390 if (mvar == NULL)
391 {
049b0c3a 392 if (reason)
57028622
NC		 393 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
394 (unsigned long long) amt, reason);
a6e9f9df
AM		 395 return NULL;
396 }
c256ffe7 397
c9c1d674 398 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 399 }
400
57028622 401 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 402 {
049b0c3a 403 if (reason)
57028622
NC		 404 error (_("Unable to read in 0x%llx bytes of %s\n"),
405 (unsigned long long) amt, reason);
a6e9f9df
AM		 406 if (mvar != var)
407 free (mvar);
408 return NULL;
409 }
410
411 return mvar;
412}
413
14a91970 414/* Print a VMA value. */
cb8f3167 415
66543521 416static int
14a91970 417print_vma (bfd_vma vma, print_mode mode)
66543521 418{
66543521
AM		 419 int nc = 0;
420
14a91970 421 switch (mode)
66543521 422 {
14a91970
AM		 423 case FULL_HEX:
424 nc = printf ("0x");
425 /* Drop through. */
66543521 426
14a91970 427 case LONG_HEX:
f7a99963 428#ifdef BFD64
14a91970 429 if (is_32bit_elf)
437c2fb7 430 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 431#endif
14a91970
AM		 432 printf_vma (vma);
433 return nc + 16;
b19aac67 434
14a91970
AM		 435 case DEC_5:
436 if (vma <= 99999)
437 return printf ("%5" BFD_VMA_FMT "d", vma);
438 /* Drop through. */
66543521 439
14a91970
AM		 440 case PREFIX_HEX:
441 nc = printf ("0x");
442 /* Drop through. */
66543521 443
14a91970
AM		 444 case HEX:
445 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 446
14a91970
AM		 447 case DEC:
448 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 449
14a91970
AM		 450 case UNSIGNED:
451 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 452 }
66543521 453 return 0;
f7a99963
NC		 454}
455
7bfd842d 456/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 457 multibye characters (assuming the host environment supports them).
31104126 458
7bfd842d
NC		 459 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
460
461 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
462 padding as necessary.
171191ba
NC		 463
464 Returns the number of emitted characters. */
465
466static unsigned int
7a88bc9c 467print_symbol (int width, const char *symbol)
31104126 468{
171191ba 469 bfd_boolean extra_padding = FALSE;
7bfd842d 470 int num_printed = 0;
3bfcb652 471#ifdef HAVE_MBSTATE_T
7bfd842d 472 mbstate_t state;
3bfcb652 473#endif
7bfd842d 474 int width_remaining;
961c521f 475
7bfd842d 476 if (width < 0)
961c521f 477 {
961c521f
NC		 478 /* Keep the width positive. This also helps. */
479 width = - width;
171191ba 480 extra_padding = TRUE;
0b4362b0 481 }
74e1a04b 482 assert (width != 0);
961c521f 483
7bfd842d
NC		 484 if (do_wide)
485 /* Set the remaining width to a very large value.
486 This simplifies the code below. */
487 width_remaining = INT_MAX;
488 else
489 width_remaining = width;
cb8f3167 490
3bfcb652 491#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 492 /* Initialise the multibyte conversion state. */
493 memset (& state, 0, sizeof (state));
3bfcb652 494#endif
961c521f 495
7bfd842d
NC		 496 while (width_remaining)
497 {
498 size_t n;
7bfd842d 499 const char c = *symbol++;
961c521f 500
7bfd842d 501 if (c == 0)
961c521f
NC		 502 break;
503
7bfd842d
NC		 504 /* Do not print control characters directly as they can affect terminal
505 settings. Such characters usually appear in the names generated
506 by the assembler for local labels. */
507 if (ISCNTRL (c))
961c521f 508 {
7bfd842d 509 if (width_remaining < 2)
961c521f
NC		 510 break;
511
7bfd842d
NC		 512 printf ("^%c", c + 0x40);
513 width_remaining -= 2;
171191ba 514 num_printed += 2;
961c521f 515 }
7bfd842d
NC		 516 else if (ISPRINT (c))
517 {
518 putchar (c);
519 width_remaining --;
520 num_printed ++;
521 }
961c521f
NC		 522 else
523 {
3bfcb652
NC		 524#ifdef HAVE_MBSTATE_T
525 wchar_t w;
526#endif
7bfd842d
NC		 527 /* Let printf do the hard work of displaying multibyte characters. */
528 printf ("%.1s", symbol - 1);
529 width_remaining --;
530 num_printed ++;
531
3bfcb652 532#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 533 /* Try to find out how many bytes made up the character that was
534 just printed. Advance the symbol pointer past the bytes that
535 were displayed. */
536 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 537#else
538 n = 1;
539#endif
7bfd842d
NC		 540 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
541 symbol += (n - 1);
961c521f 542 }
961c521f 543 }
171191ba 544
7bfd842d 545 if (extra_padding && num_printed < width)
171191ba
NC		 546 {
547 /* Fill in the remaining spaces. */
7bfd842d
NC		 548 printf ("%-*s", width - num_printed, " ");
549 num_printed = width;
171191ba
NC		 550 }
551
552 return num_printed;
31104126
NC		 553}
554
74e1a04b
NC		 555/* Returns a pointer to a static buffer containing a printable version of
556 the given section's name. Like print_symbol, except that it does not try
557 to print multibyte characters, it just interprets them as hex values. */
558
559static const char *
0d2a7a93 560printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 561{
562#define MAX_PRINT_SEC_NAME_LEN 128
563 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
564 const char * name = SECTION_NAME (sec);
565 char * buf = sec_name_buf;
566 char c;
567 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
568
569 while ((c = * name ++) != 0)
570 {
571 if (ISCNTRL (c))
572 {
573 if (remaining < 2)
574 break;
948f632f 575
74e1a04b
NC		 576 * buf ++ = '^';
577 * buf ++ = c + 0x40;
578 remaining -= 2;
579 }
580 else if (ISPRINT (c))
581 {
582 * buf ++ = c;
583 remaining -= 1;
584 }
585 else
586 {
587 static char hex[17] = "0123456789ABCDEF";
588
589 if (remaining < 4)
590 break;
591 * buf ++ = '<';
592 * buf ++ = hex[(c & 0xf0) >> 4];
593 * buf ++ = hex[c & 0x0f];
594 * buf ++ = '>';
595 remaining -= 4;
596 }
597
598 if (remaining == 0)
599 break;
600 }
601
602 * buf = 0;
603 return sec_name_buf;
604}
605
606static const char *
607printable_section_name_from_index (unsigned long ndx)
608{
609 if (ndx >= elf_header.e_shnum)
610 return _("<corrupt>");
611
612 return printable_section_name (section_headers + ndx);
613}
614
89fac5e3
RS		 615/* Return a pointer to section NAME, or NULL if no such section exists. */
616
617static Elf_Internal_Shdr *
2cf0635d 618find_section (const char * name)
89fac5e3
RS		 619{
620 unsigned int i;
621
622 for (i = 0; i < elf_header.e_shnum; i++)
623 if (streq (SECTION_NAME (section_headers + i), name))
624 return section_headers + i;
625
626 return NULL;
627}
628
0b6ae522
DJ		 629/* Return a pointer to a section containing ADDR, or NULL if no such
630 section exists. */
631
632static Elf_Internal_Shdr *
633find_section_by_address (bfd_vma addr)
634{
635 unsigned int i;
636
637 for (i = 0; i < elf_header.e_shnum; i++)
638 {
639 Elf_Internal_Shdr *sec = section_headers + i;
640 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
641 return sec;
642 }
643
644 return NULL;
645}
646
071436c6
NC		 647static Elf_Internal_Shdr *
648find_section_by_type (unsigned int type)
649{
650 unsigned int i;
651
652 for (i = 0; i < elf_header.e_shnum; i++)
653 {
654 Elf_Internal_Shdr *sec = section_headers + i;
655 if (sec->sh_type == type)
656 return sec;
657 }
658
659 return NULL;
660}
661
657d0d47
CC		 662/* Return a pointer to section NAME, or NULL if no such section exists,
663 restricted to the list of sections given in SET. */
664
665static Elf_Internal_Shdr *
666find_section_in_set (const char * name, unsigned int * set)
667{
668 unsigned int i;
669
670 if (set != NULL)
671 {
672 while ((i = *set++) > 0)
673 if (streq (SECTION_NAME (section_headers + i), name))
674 return section_headers + i;
675 }
676
677 return find_section (name);
678}
679
0b6ae522
DJ		 680/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
681 bytes read. */
682
f6f0e17b
NC		 683static inline unsigned long
684read_uleb128 (unsigned char *data,
685 unsigned int *length_return,
686 const unsigned char * const end)
0b6ae522 687{
f6f0e17b 688 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 689}
690
28f997cf
TG		 691/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
692 This OS has so many departures from the ELF standard that we test it at
693 many places. */
694
695static inline int
696is_ia64_vms (void)
697{
698 return elf_header.e_machine == EM_IA_64
699 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
700}
701
bcedfee6 702/* Guess the relocation size commonly used by the specific machines. */
252b5132 703
252b5132 704static int
2dc4cec1 705guess_is_rela (unsigned int e_machine)
252b5132 706{
9c19a809 707 switch (e_machine)
252b5132
RH		 708 {
709 /* Targets that use REL relocations. */
252b5132 710 case EM_386:
22abe556 711 case EM_IAMCU:
63fcb9e9 712 case EM_960:
e9f53129 713 case EM_ARM:
2b0337b0 714 case EM_D10V:
252b5132 715 case EM_CYGNUS_D10V:
e9f53129 716 case EM_DLX:
252b5132 717 case EM_MIPS:
4fe85591 718 case EM_MIPS_RS3_LE:
e9f53129 719 case EM_CYGNUS_M32R:
1c0d3aa6 720 case EM_SCORE:
f6c1a2d5 721 case EM_XGATE:
9c19a809 722 return FALSE;
103f02d3 723
252b5132
RH		 724 /* Targets that use RELA relocations. */
725 case EM_68K:
e9f53129 726 case EM_860:
a06ea964 727 case EM_AARCH64:
cfb8c092 728 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 729 case EM_ALPHA:
730 case EM_ALTERA_NIOS2:
886a2506
NC		 731 case EM_ARC:
732 case EM_ARC_COMPACT:
733 case EM_ARC_COMPACT2:
e9f53129
AM		 734 case EM_AVR:
735 case EM_AVR_OLD:
736 case EM_BLACKFIN:
60bca95a 737 case EM_CR16:
e9f53129
AM		 738 case EM_CRIS:
739 case EM_CRX:
2b0337b0 740 case EM_D30V:
252b5132 741 case EM_CYGNUS_D30V:
2b0337b0 742 case EM_FR30:
3f8107ab 743 case EM_FT32:
252b5132 744 case EM_CYGNUS_FR30:
5c70f934 745 case EM_CYGNUS_FRV:
e9f53129
AM		 746 case EM_H8S:
747 case EM_H8_300:
748 case EM_H8_300H:
800eeca4 749 case EM_IA_64:
1e4cf259
NC		 750 case EM_IP2K:
751 case EM_IP2K_OLD:
3b36097d 752 case EM_IQ2000:
84e94c90 753 case EM_LATTICEMICO32:
ff7eeb89 754 case EM_M32C_OLD:
49f58d10 755 case EM_M32C:
e9f53129
AM		 756 case EM_M32R:
757 case EM_MCORE:
15ab5209 758 case EM_CYGNUS_MEP:
a3c62988 759 case EM_METAG:
e9f53129
AM		 760 case EM_MMIX:
761 case EM_MN10200:
762 case EM_CYGNUS_MN10200:
763 case EM_MN10300:
764 case EM_CYGNUS_MN10300:
5506d11a 765 case EM_MOXIE:
e9f53129
AM		 766 case EM_MSP430:
767 case EM_MSP430_OLD:
d031aafb 768 case EM_MT:
35c08157 769 case EM_NDS32:
64fd6348 770 case EM_NIOS32:
73589c9d 771 case EM_OR1K:
e9f53129
AM		 772 case EM_PPC64:
773 case EM_PPC:
99c513f6 774 case EM_RL78:
c7927a3c 775 case EM_RX:
e9f53129
AM		 776 case EM_S390:
777 case EM_S390_OLD:
778 case EM_SH:
779 case EM_SPARC:
780 case EM_SPARC32PLUS:
781 case EM_SPARCV9:
782 case EM_SPU:
40b36596 783 case EM_TI_C6000:
aa137e4d
NC		 784 case EM_TILEGX:
785 case EM_TILEPRO:
708e2187 786 case EM_V800:
e9f53129
AM		 787 case EM_V850:
788 case EM_CYGNUS_V850:
789 case EM_VAX:
619ed720 790 case EM_VISIUM:
e9f53129 791 case EM_X86_64:
8a9036a4 792 case EM_L1OM:
7a9068fe 793 case EM_K1OM:
e9f53129
AM		 794 case EM_XSTORMY16:
795 case EM_XTENSA:
796 case EM_XTENSA_OLD:
7ba29e2a
NC		 797 case EM_MICROBLAZE:
798 case EM_MICROBLAZE_OLD:
9c19a809 799 return TRUE;
103f02d3 800
e9f53129
AM		 801 case EM_68HC05:
802 case EM_68HC08:
803 case EM_68HC11:
804 case EM_68HC16:
805 case EM_FX66:
806 case EM_ME16:
d1133906 807 case EM_MMA:
d1133906
NC		 808 case EM_NCPU:
809 case EM_NDR1:
e9f53129 810 case EM_PCP:
d1133906 811 case EM_ST100:
e9f53129 812 case EM_ST19:
d1133906 813 case EM_ST7:
e9f53129
AM		 814 case EM_ST9PLUS:
815 case EM_STARCORE:
d1133906 816 case EM_SVX:
e9f53129 817 case EM_TINYJ:
9c19a809
NC		 818 default:
819 warn (_("Don't know about relocations on this machine architecture\n"));
820 return FALSE;
821 }
822}
252b5132 823
9c19a809 824static int
2cf0635d 825slurp_rela_relocs (FILE * file,
d3ba0551
AM		 826 unsigned long rel_offset,
827 unsigned long rel_size,
2cf0635d
NC		 828 Elf_Internal_Rela ** relasp,
829 unsigned long * nrelasp)
9c19a809 830{
2cf0635d 831 Elf_Internal_Rela * relas;
8b73c356 832 size_t nrelas;
4d6ed7c8 833 unsigned int i;
252b5132 834
4d6ed7c8
NC		 835 if (is_32bit_elf)
836 {
2cf0635d 837 Elf32_External_Rela * erelas;
103f02d3 838
3f5e193b 839 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 840 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 841 if (!erelas)
842 return 0;
252b5132 843
4d6ed7c8 844 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 845
3f5e193b
NC		 846 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
847 sizeof (Elf_Internal_Rela));
103f02d3 848
4d6ed7c8
NC		 849 if (relas == NULL)
850 {
c256ffe7 851 free (erelas);
591a748a 852 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 853 return 0;
854 }
103f02d3 855
4d6ed7c8
NC		 856 for (i = 0; i < nrelas; i++)
857 {
858 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
859 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 860 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 861 }
103f02d3 862
4d6ed7c8
NC		 863 free (erelas);
864 }
865 else
866 {
2cf0635d 867 Elf64_External_Rela * erelas;
103f02d3 868
3f5e193b 869 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 870 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 871 if (!erelas)
872 return 0;
4d6ed7c8
NC		 873
874 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 875
3f5e193b
NC		 876 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
877 sizeof (Elf_Internal_Rela));
103f02d3 878
4d6ed7c8
NC		 879 if (relas == NULL)
880 {
c256ffe7 881 free (erelas);
591a748a 882 error (_("out of memory parsing relocs\n"));
4d6ed7c8 883 return 0;
9c19a809 884 }
4d6ed7c8
NC		 885
886 for (i = 0; i < nrelas; i++)
9c19a809 887 {
66543521
AM		 888 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
889 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 890 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 891
892 /* The #ifdef BFD64 below is to prevent a compile time
893 warning. We know that if we do not have a 64 bit data
894 type that we will never execute this code anyway. */
895#ifdef BFD64
896 if (elf_header.e_machine == EM_MIPS
897 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
898 {
899 /* In little-endian objects, r_info isn't really a
900 64-bit little-endian value: it has a 32-bit
901 little-endian symbol index followed by four
902 individual byte fields. Reorder INFO
903 accordingly. */
91d6fa6a
NC		 904 bfd_vma inf = relas[i].r_info;
905 inf = (((inf & 0xffffffff) << 32)
906 | ((inf >> 56) & 0xff)
907 | ((inf >> 40) & 0xff00)
908 | ((inf >> 24) & 0xff0000)
909 | ((inf >> 8) & 0xff000000));
910 relas[i].r_info = inf;
861fb55a
DJ		 911 }
912#endif /* BFD64 */
4d6ed7c8 913 }
103f02d3 914
4d6ed7c8
NC		 915 free (erelas);
916 }
917 *relasp = relas;
918 *nrelasp = nrelas;
919 return 1;
920}
103f02d3 921
4d6ed7c8 922static int
2cf0635d 923slurp_rel_relocs (FILE * file,
d3ba0551
AM		 924 unsigned long rel_offset,
925 unsigned long rel_size,
2cf0635d
NC		 926 Elf_Internal_Rela ** relsp,
927 unsigned long * nrelsp)
4d6ed7c8 928{
2cf0635d 929 Elf_Internal_Rela * rels;
8b73c356 930 size_t nrels;
4d6ed7c8 931 unsigned int i;
103f02d3 932
4d6ed7c8
NC		 933 if (is_32bit_elf)
934 {
2cf0635d 935 Elf32_External_Rel * erels;
103f02d3 936
3f5e193b 937 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 938 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 939 if (!erels)
940 return 0;
103f02d3 941
4d6ed7c8 942 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 943
3f5e193b 944 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 945
4d6ed7c8
NC		 946 if (rels == NULL)
947 {
c256ffe7 948 free (erels);
591a748a 949 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 950 return 0;
951 }
952
953 for (i = 0; i < nrels; i++)
954 {
955 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
956 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 957 rels[i].r_addend = 0;
9ea033b2 958 }
4d6ed7c8
NC		 959
960 free (erels);
9c19a809
NC		 961 }
962 else
963 {
2cf0635d 964 Elf64_External_Rel * erels;
9ea033b2 965
3f5e193b 966 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 967 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 968 if (!erels)
969 return 0;
103f02d3 970
4d6ed7c8 971 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 972
3f5e193b 973 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 974
4d6ed7c8 975 if (rels == NULL)
9c19a809 976 {
c256ffe7 977 free (erels);
591a748a 978 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 979 return 0;
980 }
103f02d3 981
4d6ed7c8
NC		 982 for (i = 0; i < nrels; i++)
983 {
66543521
AM		 984 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
985 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 986 rels[i].r_addend = 0;
861fb55a
DJ		 987
988 /* The #ifdef BFD64 below is to prevent a compile time
989 warning. We know that if we do not have a 64 bit data
990 type that we will never execute this code anyway. */
991#ifdef BFD64
992 if (elf_header.e_machine == EM_MIPS
993 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
994 {
995 /* In little-endian objects, r_info isn't really a
996 64-bit little-endian value: it has a 32-bit
997 little-endian symbol index followed by four
998 individual byte fields. Reorder INFO
999 accordingly. */
91d6fa6a
NC		 1000 bfd_vma inf = rels[i].r_info;
1001 inf = (((inf & 0xffffffff) << 32)
1002 | ((inf >> 56) & 0xff)
1003 | ((inf >> 40) & 0xff00)
1004 | ((inf >> 24) & 0xff0000)
1005 | ((inf >> 8) & 0xff000000));
1006 rels[i].r_info = inf;
861fb55a
DJ		 1007 }
1008#endif /* BFD64 */
4d6ed7c8 1009 }
103f02d3 1010
4d6ed7c8
NC		 1011 free (erels);
1012 }
1013 *relsp = rels;
1014 *nrelsp = nrels;
1015 return 1;
1016}
103f02d3 1017
aca88567
NC		 1018/* Returns the reloc type extracted from the reloc info field. */
1019
1020static unsigned int
1021get_reloc_type (bfd_vma reloc_info)
1022{
1023 if (is_32bit_elf)
1024 return ELF32_R_TYPE (reloc_info);
1025
1026 switch (elf_header.e_machine)
1027 {
1028 case EM_MIPS:
1029 /* Note: We assume that reloc_info has already been adjusted for us. */
1030 return ELF64_MIPS_R_TYPE (reloc_info);
1031
1032 case EM_SPARCV9:
1033 return ELF64_R_TYPE_ID (reloc_info);
1034
1035 default:
1036 return ELF64_R_TYPE (reloc_info);
1037 }
1038}
1039
1040/* Return the symbol index extracted from the reloc info field. */
1041
1042static bfd_vma
1043get_reloc_symindex (bfd_vma reloc_info)
1044{
1045 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1046}
1047
13761a11
NC		 1048static inline bfd_boolean
1049uses_msp430x_relocs (void)
1050{
1051 return
1052 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1053 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1054 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1055 /* TI compiler uses ELFOSABI_NONE. */
1056 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1057}
1058
d3ba0551
AM		 1059/* Display the contents of the relocation data found at the specified
1060 offset. */
ee42cf8c 1061
41e92641 1062static void
2cf0635d 1063dump_relocations (FILE * file,
d3ba0551
AM		 1064 unsigned long rel_offset,
1065 unsigned long rel_size,
2cf0635d 1066 Elf_Internal_Sym * symtab,
d3ba0551 1067 unsigned long nsyms,
2cf0635d 1068 char * strtab,
d79b3d50 1069 unsigned long strtablen,
bb4d2ac2
L		 1070 int is_rela,
1071 int is_dynsym)
4d6ed7c8 1072{
b34976b6 1073 unsigned int i;
2cf0635d 1074 Elf_Internal_Rela * rels;
103f02d3 1075
4d6ed7c8
NC		 1076 if (is_rela == UNKNOWN)
1077 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1078
4d6ed7c8
NC		 1079 if (is_rela)
1080 {
c8286bd1 1081 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1082 return;
4d6ed7c8
NC		 1083 }
1084 else
1085 {
1086 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1087 return;
252b5132
RH		 1088 }
1089
410f7a12
L		 1090 if (is_32bit_elf)
1091 {
1092 if (is_rela)
2c71103e
NC		 1093 {
1094 if (do_wide)
1095 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1096 else
1097 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1098 }
410f7a12 1099 else
2c71103e
NC		 1100 {
1101 if (do_wide)
1102 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1103 else
1104 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1105 }
410f7a12 1106 }
252b5132 1107 else
410f7a12
L		 1108 {
1109 if (is_rela)
2c71103e
NC		 1110 {
1111 if (do_wide)
8beeaeb7 1112 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1113 else
1114 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1115 }
410f7a12 1116 else
2c71103e
NC		 1117 {
1118 if (do_wide)
8beeaeb7 1119 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1120 else
1121 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1122 }
410f7a12 1123 }
252b5132
RH		 1124
1125 for (i = 0; i < rel_size; i++)
1126 {
2cf0635d 1127 const char * rtype;
b34976b6 1128 bfd_vma offset;
91d6fa6a 1129 bfd_vma inf;
b34976b6
AM		 1130 bfd_vma symtab_index;
1131 bfd_vma type;
103f02d3 1132
b34976b6 1133 offset = rels[i].r_offset;
91d6fa6a 1134 inf = rels[i].r_info;
103f02d3 1135
91d6fa6a
NC		 1136 type = get_reloc_type (inf);
1137 symtab_index = get_reloc_symindex (inf);
252b5132 1138
410f7a12
L		 1139 if (is_32bit_elf)
1140 {
39dbeff8
AM		 1141 printf ("%8.8lx %8.8lx ",
1142 (unsigned long) offset & 0xffffffff,
91d6fa6a 1143 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1144 }
1145 else
1146 {
39dbeff8
AM		 1147#if BFD_HOST_64BIT_LONG
1148 printf (do_wide
1149 ? "%16.16lx %16.16lx "
1150 : "%12.12lx %12.12lx ",
91d6fa6a 1151 offset, inf);
39dbeff8 1152#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1153#ifndef __MSVCRT__
39dbeff8
AM		 1154 printf (do_wide
1155 ? "%16.16llx %16.16llx "
1156 : "%12.12llx %12.12llx ",
91d6fa6a 1157 offset, inf);
6e3d6dc1
NC		 1158#else
1159 printf (do_wide
1160 ? "%16.16I64x %16.16I64x "
1161 : "%12.12I64x %12.12I64x ",
91d6fa6a 1162 offset, inf);
6e3d6dc1 1163#endif
39dbeff8 1164#else
2c71103e
NC		 1165 printf (do_wide
1166 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1167 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1168 _bfd_int64_high (offset),
1169 _bfd_int64_low (offset),
91d6fa6a
NC		 1170 _bfd_int64_high (inf),
1171 _bfd_int64_low (inf));
9ea033b2 1172#endif
410f7a12 1173 }
103f02d3 1174
252b5132
RH		 1175 switch (elf_header.e_machine)
1176 {
1177 default:
1178 rtype = NULL;
1179 break;
1180
a06ea964
NC		 1181 case EM_AARCH64:
1182 rtype = elf_aarch64_reloc_type (type);
1183 break;
1184
2b0337b0 1185 case EM_M32R:
252b5132 1186 case EM_CYGNUS_M32R:
9ea033b2 1187 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1188 break;
1189
1190 case EM_386:
22abe556 1191 case EM_IAMCU:
9ea033b2 1192 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1193 break;
1194
ba2685cc
AM		 1195 case EM_68HC11:
1196 case EM_68HC12:
1197 rtype = elf_m68hc11_reloc_type (type);
1198 break;
75751cd9 1199
252b5132 1200 case EM_68K:
9ea033b2 1201 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1202 break;
1203
63fcb9e9 1204 case EM_960:
9ea033b2 1205 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1206 break;
1207
adde6300 1208 case EM_AVR:
2b0337b0 1209 case EM_AVR_OLD:
adde6300
AM		 1210 rtype = elf_avr_reloc_type (type);
1211 break;
1212
9ea033b2
NC		 1213 case EM_OLD_SPARCV9:
1214 case EM_SPARC32PLUS:
1215 case EM_SPARCV9:
252b5132 1216 case EM_SPARC:
9ea033b2 1217 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1218 break;
1219
e9f53129
AM		 1220 case EM_SPU:
1221 rtype = elf_spu_reloc_type (type);
1222 break;
1223
708e2187
NC		 1224 case EM_V800:
1225 rtype = v800_reloc_type (type);
1226 break;
2b0337b0 1227 case EM_V850:
252b5132 1228 case EM_CYGNUS_V850:
9ea033b2 1229 rtype = v850_reloc_type (type);
252b5132
RH		 1230 break;
1231
2b0337b0 1232 case EM_D10V:
252b5132 1233 case EM_CYGNUS_D10V:
9ea033b2 1234 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1235 break;
1236
2b0337b0 1237 case EM_D30V:
252b5132 1238 case EM_CYGNUS_D30V:
9ea033b2 1239 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1240 break;
1241
d172d4ba
NC		 1242 case EM_DLX:
1243 rtype = elf_dlx_reloc_type (type);
1244 break;
1245
252b5132 1246 case EM_SH:
9ea033b2 1247 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1248 break;
1249
2b0337b0 1250 case EM_MN10300:
252b5132 1251 case EM_CYGNUS_MN10300:
9ea033b2 1252 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1253 break;
1254
2b0337b0 1255 case EM_MN10200:
252b5132 1256 case EM_CYGNUS_MN10200:
9ea033b2 1257 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1258 break;
1259
2b0337b0 1260 case EM_FR30:
252b5132 1261 case EM_CYGNUS_FR30:
9ea033b2 1262 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1263 break;
1264
ba2685cc
AM		 1265 case EM_CYGNUS_FRV:
1266 rtype = elf_frv_reloc_type (type);
1267 break;
5c70f934 1268
3f8107ab
AM		 1269 case EM_FT32:
1270 rtype = elf_ft32_reloc_type (type);
1271 break;
1272
252b5132 1273 case EM_MCORE:
9ea033b2 1274 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1275 break;
1276
3c3bdf30
NC		 1277 case EM_MMIX:
1278 rtype = elf_mmix_reloc_type (type);
1279 break;
1280
5506d11a
AM		 1281 case EM_MOXIE:
1282 rtype = elf_moxie_reloc_type (type);
1283 break;
1284
2469cfa2 1285 case EM_MSP430:
13761a11
NC		 1286 if (uses_msp430x_relocs ())
1287 {
1288 rtype = elf_msp430x_reloc_type (type);
1289 break;
1290 }
2469cfa2
NC		 1291 case EM_MSP430_OLD:
1292 rtype = elf_msp430_reloc_type (type);
1293 break;
1294
35c08157
KLC		 1295 case EM_NDS32:
1296 rtype = elf_nds32_reloc_type (type);
1297 break;
1298
252b5132 1299 case EM_PPC:
9ea033b2 1300 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1301 break;
1302
c833c019
AM		 1303 case EM_PPC64:
1304 rtype = elf_ppc64_reloc_type (type);
1305 break;
1306
252b5132 1307 case EM_MIPS:
4fe85591 1308 case EM_MIPS_RS3_LE:
9ea033b2 1309 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1310 break;
1311
1312 case EM_ALPHA:
9ea033b2 1313 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_ARM:
9ea033b2 1317 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1318 break;
1319
584da044 1320 case EM_ARC:
886a2506
NC		 1321 case EM_ARC_COMPACT:
1322 case EM_ARC_COMPACT2:
9ea033b2 1323 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1324 break;
1325
1326 case EM_PARISC:
69e617ca 1327 rtype = elf_hppa_reloc_type (type);
252b5132 1328 break;
7d466069 1329
b8720f9d
JL		 1330 case EM_H8_300:
1331 case EM_H8_300H:
1332 case EM_H8S:
1333 rtype = elf_h8_reloc_type (type);
1334 break;
1335
73589c9d
CS		 1336 case EM_OR1K:
1337 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1338 break;
1339
7d466069 1340 case EM_PJ:
2b0337b0 1341 case EM_PJ_OLD:
7d466069
ILT		 1342 rtype = elf_pj_reloc_type (type);
1343 break;
800eeca4
JW		 1344 case EM_IA_64:
1345 rtype = elf_ia64_reloc_type (type);
1346 break;
1b61cf92
HPN		 1347
1348 case EM_CRIS:
1349 rtype = elf_cris_reloc_type (type);
1350 break;
535c37ff
JE		 1351
1352 case EM_860:
1353 rtype = elf_i860_reloc_type (type);
1354 break;
bcedfee6
NC		 1355
1356 case EM_X86_64:
8a9036a4 1357 case EM_L1OM:
7a9068fe 1358 case EM_K1OM:
bcedfee6
NC		 1359 rtype = elf_x86_64_reloc_type (type);
1360 break;
a85d7ed0 1361
35b1837e
AM		 1362 case EM_S370:
1363 rtype = i370_reloc_type (type);
1364 break;
1365
53c7db4b
KH		 1366 case EM_S390_OLD:
1367 case EM_S390:
1368 rtype = elf_s390_reloc_type (type);
1369 break;
93fbbb04 1370
1c0d3aa6
NC		 1371 case EM_SCORE:
1372 rtype = elf_score_reloc_type (type);
1373 break;
1374
93fbbb04
GK		 1375 case EM_XSTORMY16:
1376 rtype = elf_xstormy16_reloc_type (type);
1377 break;
179d3252 1378
1fe1f39c
NC		 1379 case EM_CRX:
1380 rtype = elf_crx_reloc_type (type);
1381 break;
1382
179d3252
JT		 1383 case EM_VAX:
1384 rtype = elf_vax_reloc_type (type);
1385 break;
1e4cf259 1386
619ed720
EB		 1387 case EM_VISIUM:
1388 rtype = elf_visium_reloc_type (type);
1389 break;
1390
cfb8c092
NC		 1391 case EM_ADAPTEVA_EPIPHANY:
1392 rtype = elf_epiphany_reloc_type (type);
1393 break;
1394
1e4cf259
NC		 1395 case EM_IP2K:
1396 case EM_IP2K_OLD:
1397 rtype = elf_ip2k_reloc_type (type);
1398 break;
3b36097d
SC		 1399
1400 case EM_IQ2000:
1401 rtype = elf_iq2000_reloc_type (type);
1402 break;
88da6820
NC		 1403
1404 case EM_XTENSA_OLD:
1405 case EM_XTENSA:
1406 rtype = elf_xtensa_reloc_type (type);
1407 break;
a34e3ecb 1408
84e94c90
NC		 1409 case EM_LATTICEMICO32:
1410 rtype = elf_lm32_reloc_type (type);
1411 break;
1412
ff7eeb89 1413 case EM_M32C_OLD:
49f58d10
JB		 1414 case EM_M32C:
1415 rtype = elf_m32c_reloc_type (type);
1416 break;
1417
d031aafb
NS		 1418 case EM_MT:
1419 rtype = elf_mt_reloc_type (type);
a34e3ecb 1420 break;
1d65ded4
CM		 1421
1422 case EM_BLACKFIN:
1423 rtype = elf_bfin_reloc_type (type);
1424 break;
15ab5209
DB		 1425
1426 case EM_CYGNUS_MEP:
1427 rtype = elf_mep_reloc_type (type);
1428 break;
60bca95a
NC		 1429
1430 case EM_CR16:
1431 rtype = elf_cr16_reloc_type (type);
1432 break;
dd24e3da 1433
7ba29e2a
NC		 1434 case EM_MICROBLAZE:
1435 case EM_MICROBLAZE_OLD:
1436 rtype = elf_microblaze_reloc_type (type);
1437 break;
c7927a3c 1438
99c513f6
DD		 1439 case EM_RL78:
1440 rtype = elf_rl78_reloc_type (type);
1441 break;
1442
c7927a3c
NC		 1443 case EM_RX:
1444 rtype = elf_rx_reloc_type (type);
1445 break;
c29aca4a 1446
a3c62988
NC		 1447 case EM_METAG:
1448 rtype = elf_metag_reloc_type (type);
1449 break;
1450
c29aca4a
NC		 1451 case EM_XC16X:
1452 case EM_C166:
1453 rtype = elf_xc16x_reloc_type (type);
1454 break;
40b36596
JM		 1455
1456 case EM_TI_C6000:
1457 rtype = elf_tic6x_reloc_type (type);
1458 break;
aa137e4d
NC		 1459
1460 case EM_TILEGX:
1461 rtype = elf_tilegx_reloc_type (type);
1462 break;
1463
1464 case EM_TILEPRO:
1465 rtype = elf_tilepro_reloc_type (type);
1466 break;
f6c1a2d5
NC		 1467
1468 case EM_XGATE:
1469 rtype = elf_xgate_reloc_type (type);
1470 break;
36591ba1
SL		 1471
1472 case EM_ALTERA_NIOS2:
1473 rtype = elf_nios2_reloc_type (type);
1474 break;
252b5132
RH		 1475 }
1476
1477 if (rtype == NULL)
39dbeff8 1478 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1479 else
8beeaeb7 1480 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1481
7ace3541 1482 if (elf_header.e_machine == EM_ALPHA
157c2599 1483 && rtype != NULL
7ace3541
RH		 1484 && streq (rtype, "R_ALPHA_LITUSE")
1485 && is_rela)
1486 {
1487 switch (rels[i].r_addend)
1488 {
1489 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1490 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1491 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1492 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1493 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1494 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1495 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1496 default: rtype = NULL;
1497 }
1498 if (rtype)
1499 printf (" (%s)", rtype);
1500 else
1501 {
1502 putchar (' ');
1503 printf (_("<unknown addend: %lx>"),
1504 (unsigned long) rels[i].r_addend);
1505 }
1506 }
1507 else if (symtab_index)
252b5132 1508 {
af3fc3bc 1509 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1510 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1511 else
19936277 1512 {
2cf0635d 1513 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1514 const char * version_string;
1515 enum versioned_symbol_info sym_info;
1516 unsigned short vna_other;
19936277 1517
af3fc3bc 1518 psym = symtab + symtab_index;
103f02d3 1519
bb4d2ac2
L		 1520 version_string
1521 = get_symbol_version_string (file, is_dynsym,
1522 strtab, strtablen,
1523 symtab_index,
1524 psym,
1525 &sym_info,
1526 &vna_other);
1527
af3fc3bc 1528 printf (" ");
171191ba 1529
d8045f23
NC		 1530 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1531 {
1532 const char * name;
1533 unsigned int len;
1534 unsigned int width = is_32bit_elf ? 8 : 14;
1535
1536 /* Relocations against GNU_IFUNC symbols do not use the value
1537 of the symbol as the address to relocate against. Instead
1538 they invoke the function named by the symbol and use its
1539 result as the address for relocation.
1540
1541 To indicate this to the user, do not display the value of
1542 the symbol in the "Symbols's Value" field. Instead show
1543 its name followed by () as a hint that the symbol is
1544 invoked. */
1545
1546 if (strtab == NULL
1547 || psym->st_name == 0
1548 || psym->st_name >= strtablen)
1549 name = "??";
1550 else
1551 name = strtab + psym->st_name;
1552
1553 len = print_symbol (width, name);
bb4d2ac2
L		 1554 if (version_string)
1555 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1556 version_string);
d8045f23
NC		 1557 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1558 }
1559 else
1560 {
1561 print_vma (psym->st_value, LONG_HEX);
171191ba 1562
d8045f23
NC		 1563 printf (is_32bit_elf ? " " : " ");
1564 }
103f02d3 1565
af3fc3bc 1566 if (psym->st_name == 0)
f1ef08cb 1567 {
2cf0635d 1568 const char * sec_name = "<null>";
f1ef08cb
AM		 1569 char name_buf[40];
1570
1571 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1572 {
4fbb74a6 1573 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1574 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1575 else if (psym->st_shndx == SHN_ABS)
1576 sec_name = "ABS";
1577 else if (psym->st_shndx == SHN_COMMON)
1578 sec_name = "COMMON";
ac145307
BS		 1579 else if ((elf_header.e_machine == EM_MIPS
1580 && psym->st_shndx == SHN_MIPS_SCOMMON)
1581 || (elf_header.e_machine == EM_TI_C6000
1582 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1583 sec_name = "SCOMMON";
1584 else if (elf_header.e_machine == EM_MIPS
1585 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1586 sec_name = "SUNDEF";
8a9036a4 1587 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1588 || elf_header.e_machine == EM_L1OM
1589 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1590 && psym->st_shndx == SHN_X86_64_LCOMMON)
1591 sec_name = "LARGE_COMMON";
9ce701e2
L		 1592 else if (elf_header.e_machine == EM_IA_64
1593 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1594 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1595 sec_name = "ANSI_COM";
28f997cf 1596 else if (is_ia64_vms ()
148b93f2
NC		 1597 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1598 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1599 else
1600 {
1601 sprintf (name_buf, "<section 0x%x>",
1602 (unsigned int) psym->st_shndx);
1603 sec_name = name_buf;
1604 }
1605 }
1606 print_symbol (22, sec_name);
1607 }
af3fc3bc 1608 else if (strtab == NULL)
d79b3d50 1609 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1610 else if (psym->st_name >= strtablen)
d79b3d50 1611 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1612 else
bb4d2ac2
L		 1613 {
1614 print_symbol (22, strtab + psym->st_name);
1615 if (version_string)
1616 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1617 version_string);
1618 }
103f02d3 1619
af3fc3bc 1620 if (is_rela)
171191ba 1621 {
7360e63f 1622 bfd_vma off = rels[i].r_addend;
171191ba 1623
7360e63f 1624 if ((bfd_signed_vma) off < 0)
598aaa76 1625 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1626 else
598aaa76 1627 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1628 }
19936277 1629 }
252b5132 1630 }
1b228002 1631 else if (is_rela)
f7a99963 1632 {
7360e63f 1633 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1634
1635 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1636 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1637 printf ("-%" BFD_VMA_FMT "x", - off);
1638 else
1639 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1640 }
252b5132 1641
157c2599
NC		 1642 if (elf_header.e_machine == EM_SPARCV9
1643 && rtype != NULL
1644 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1645 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1646
252b5132 1647 putchar ('\n');
2c71103e 1648
aca88567 1649#ifdef BFD64
53c7db4b 1650 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1651 {
91d6fa6a
NC		 1652 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1653 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1654 const char * rtype2 = elf_mips_reloc_type (type2);
1655 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1656
2c71103e
NC		 1657 printf (" Type2: ");
1658
1659 if (rtype2 == NULL)
39dbeff8
AM		 1660 printf (_("unrecognized: %-7lx"),
1661 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1662 else
1663 printf ("%-17.17s", rtype2);
1664
18bd398b 1665 printf ("\n Type3: ");
2c71103e
NC		 1666
1667 if (rtype3 == NULL)
39dbeff8
AM		 1668 printf (_("unrecognized: %-7lx"),
1669 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1670 else
1671 printf ("%-17.17s", rtype3);
1672
53c7db4b 1673 putchar ('\n');
2c71103e 1674 }
aca88567 1675#endif /* BFD64 */
252b5132
RH		 1676 }
1677
c8286bd1 1678 free (rels);
252b5132
RH		 1679}
1680
1681static const char *
d3ba0551 1682get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1683{
1684 switch (type)
1685 {
1686 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1687 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1688 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1689 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1690 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1691 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1692 case DT_MIPS_MSYM: return "MIPS_MSYM";
1693 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1694 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1695 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1696 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1697 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1698 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1699 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1700 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1701 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1702 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1703 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1704 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1705 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1706 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1707 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1708 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1709 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1710 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1711 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1712 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1713 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1714 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1715 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1716 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1717 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1718 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1719 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1720 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1721 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1722 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1723 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1724 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1725 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1727 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1728 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1729 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1730 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1731 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1732 default:
1733 return NULL;
1734 }
1735}
1736
9a097730 1737static const char *
d3ba0551 1738get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1739{
1740 switch (type)
1741 {
1742 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1743 default:
1744 return NULL;
1745 }
103f02d3
UD		 1746}
1747
7490d522
AM		 1748static const char *
1749get_ppc_dynamic_type (unsigned long type)
1750{
1751 switch (type)
1752 {
a7f2871e 1753 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1754 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1755 default:
1756 return NULL;
1757 }
1758}
1759
f1cb7e17 1760static const char *
d3ba0551 1761get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1762{
1763 switch (type)
1764 {
a7f2871e
AM		 1765 case DT_PPC64_GLINK: return "PPC64_GLINK";
1766 case DT_PPC64_OPD: return "PPC64_OPD";
1767 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1768 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1769 default:
1770 return NULL;
1771 }
1772}
1773
103f02d3 1774static const char *
d3ba0551 1775get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1776{
1777 switch (type)
1778 {
1779 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1780 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1781 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1782 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1783 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1784 case DT_HP_PREINIT: return "HP_PREINIT";
1785 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1786 case DT_HP_NEEDED: return "HP_NEEDED";
1787 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1788 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1789 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1790 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1791 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1792 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1793 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1794 case DT_HP_FILTERED: return "HP_FILTERED";
1795 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1796 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1797 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1798 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1799 case DT_PLT: return "PLT";
1800 case DT_PLT_SIZE: return "PLT_SIZE";
1801 case DT_DLT: return "DLT";
1802 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1803 default:
1804 return NULL;
1805 }
1806}
9a097730 1807
ecc51f48 1808static const char *
d3ba0551 1809get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1810{
1811 switch (type)
1812 {
148b93f2
NC		 1813 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1814 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1815 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1816 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1817 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1818 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1819 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1820 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1821 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1822 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1823 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1824 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1825 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1826 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1827 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1828 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1829 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1830 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1831 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1832 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1833 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1834 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1835 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1836 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1837 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1838 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1839 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1840 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1841 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1842 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1843 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1844 default:
1845 return NULL;
1846 }
1847}
1848
fabcb361
RH		 1849static const char *
1850get_alpha_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
1854 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1855 default:
1856 return NULL;
1857 }
1858}
1859
1c0d3aa6
NC		 1860static const char *
1861get_score_dynamic_type (unsigned long type)
1862{
1863 switch (type)
1864 {
1865 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1866 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1867 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1868 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1869 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1870 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1871 default:
1872 return NULL;
1873 }
1874}
1875
40b36596
JM		 1876static const char *
1877get_tic6x_dynamic_type (unsigned long type)
1878{
1879 switch (type)
1880 {
1881 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1882 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1883 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1884 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1885 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1886 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1887 default:
1888 return NULL;
1889 }
1890}
1c0d3aa6 1891
36591ba1
SL		 1892static const char *
1893get_nios2_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_NIOS2_GP: return "NIOS2_GP";
1898 default:
1899 return NULL;
1900 }
1901}
1902
252b5132 1903static const char *
d3ba0551 1904get_dynamic_type (unsigned long type)
252b5132 1905{
e9e44622 1906 static char buff[64];
252b5132
RH		 1907
1908 switch (type)
1909 {
1910 case DT_NULL: return "NULL";
1911 case DT_NEEDED: return "NEEDED";
1912 case DT_PLTRELSZ: return "PLTRELSZ";
1913 case DT_PLTGOT: return "PLTGOT";
1914 case DT_HASH: return "HASH";
1915 case DT_STRTAB: return "STRTAB";
1916 case DT_SYMTAB: return "SYMTAB";
1917 case DT_RELA: return "RELA";
1918 case DT_RELASZ: return "RELASZ";
1919 case DT_RELAENT: return "RELAENT";
1920 case DT_STRSZ: return "STRSZ";
1921 case DT_SYMENT: return "SYMENT";
1922 case DT_INIT: return "INIT";
1923 case DT_FINI: return "FINI";
1924 case DT_SONAME: return "SONAME";
1925 case DT_RPATH: return "RPATH";
1926 case DT_SYMBOLIC: return "SYMBOLIC";
1927 case DT_REL: return "REL";
1928 case DT_RELSZ: return "RELSZ";
1929 case DT_RELENT: return "RELENT";
1930 case DT_PLTREL: return "PLTREL";
1931 case DT_DEBUG: return "DEBUG";
1932 case DT_TEXTREL: return "TEXTREL";
1933 case DT_JMPREL: return "JMPREL";
1934 case DT_BIND_NOW: return "BIND_NOW";
1935 case DT_INIT_ARRAY: return "INIT_ARRAY";
1936 case DT_FINI_ARRAY: return "FINI_ARRAY";
1937 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1938 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1939 case DT_RUNPATH: return "RUNPATH";
1940 case DT_FLAGS: return "FLAGS";
2d0e6f43 1941
d1133906
NC		 1942 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1943 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1944
05107a46 1945 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 1946 case DT_PLTPADSZ: return "PLTPADSZ";
1947 case DT_MOVEENT: return "MOVEENT";
1948 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 1949 case DT_FEATURE: return "FEATURE";
252b5132
RH		 1950 case DT_POSFLAG_1: return "POSFLAG_1";
1951 case DT_SYMINSZ: return "SYMINSZ";
1952 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1953
252b5132 1954 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 1955 case DT_CONFIG: return "CONFIG";
1956 case DT_DEPAUDIT: return "DEPAUDIT";
1957 case DT_AUDIT: return "AUDIT";
1958 case DT_PLTPAD: return "PLTPAD";
1959 case DT_MOVETAB: return "MOVETAB";
252b5132 1960 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1961
252b5132 1962 case DT_VERSYM: return "VERSYM";
103f02d3 1963
67a4f2b7
AO		 1964 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1965 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 1966 case DT_RELACOUNT: return "RELACOUNT";
1967 case DT_RELCOUNT: return "RELCOUNT";
1968 case DT_FLAGS_1: return "FLAGS_1";
1969 case DT_VERDEF: return "VERDEF";
1970 case DT_VERDEFNUM: return "VERDEFNUM";
1971 case DT_VERNEED: return "VERNEED";
1972 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1973
019148e4 1974 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 1975 case DT_USED: return "USED";
1976 case DT_FILTER: return "FILTER";
103f02d3 1977
047b2264
JJ		 1978 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1979 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1980 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1981 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1982 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 1983 case DT_GNU_HASH: return "GNU_HASH";
047b2264 1984
252b5132
RH		 1985 default:
1986 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1987 {
2cf0635d 1988 const char * result;
103f02d3 1989
252b5132
RH		 1990 switch (elf_header.e_machine)
1991 {
1992 case EM_MIPS:
4fe85591 1993 case EM_MIPS_RS3_LE:
252b5132
RH		 1994 result = get_mips_dynamic_type (type);
1995 break;
9a097730
RH		 1996 case EM_SPARCV9:
1997 result = get_sparc64_dynamic_type (type);
1998 break;
7490d522
AM		 1999 case EM_PPC:
2000 result = get_ppc_dynamic_type (type);
2001 break;
f1cb7e17
AM		 2002 case EM_PPC64:
2003 result = get_ppc64_dynamic_type (type);
2004 break;
ecc51f48
NC		 2005 case EM_IA_64:
2006 result = get_ia64_dynamic_type (type);
2007 break;
fabcb361
RH		 2008 case EM_ALPHA:
2009 result = get_alpha_dynamic_type (type);
2010 break;
1c0d3aa6
NC		 2011 case EM_SCORE:
2012 result = get_score_dynamic_type (type);
2013 break;
40b36596
JM		 2014 case EM_TI_C6000:
2015 result = get_tic6x_dynamic_type (type);
2016 break;
36591ba1
SL		 2017 case EM_ALTERA_NIOS2:
2018 result = get_nios2_dynamic_type (type);
2019 break;
252b5132
RH		 2020 default:
2021 result = NULL;
2022 break;
2023 }
2024
2025 if (result != NULL)
2026 return result;
2027
e9e44622 2028 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2029 }
eec8f817
DA		 2030 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2031 || (elf_header.e_machine == EM_PARISC
2032 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2033 {
2cf0635d 2034 const char * result;
103f02d3
UD		 2035
2036 switch (elf_header.e_machine)
2037 {
2038 case EM_PARISC:
2039 result = get_parisc_dynamic_type (type);
2040 break;
148b93f2
NC		 2041 case EM_IA_64:
2042 result = get_ia64_dynamic_type (type);
2043 break;
103f02d3
UD		 2044 default:
2045 result = NULL;
2046 break;
2047 }
2048
2049 if (result != NULL)
2050 return result;
2051
e9e44622
JJ		 2052 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2053 type);
103f02d3 2054 }
252b5132 2055 else
e9e44622 2056 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2057
252b5132
RH		 2058 return buff;
2059 }
2060}
2061
2062static char *
d3ba0551 2063get_file_type (unsigned e_type)
252b5132 2064{
b34976b6 2065 static char buff[32];
252b5132
RH		 2066
2067 switch (e_type)
2068 {
2069 case ET_NONE: return _("NONE (None)");
2070 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2071 case ET_EXEC: return _("EXEC (Executable file)");
2072 case ET_DYN: return _("DYN (Shared object file)");
2073 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2074
2075 default:
2076 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2077 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2078 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2079 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2080 else
e9e44622 2081 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2082 return buff;
2083 }
2084}
2085
2086static char *
d3ba0551 2087get_machine_name (unsigned e_machine)
252b5132 2088{
b34976b6 2089 static char buff[64]; /* XXX */
252b5132
RH		 2090
2091 switch (e_machine)
2092 {
c45021f2 2093 case EM_NONE: return _("None");
a06ea964 2094 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2095 case EM_M32: return "WE32100";
2096 case EM_SPARC: return "Sparc";
e9f53129 2097 case EM_SPU: return "SPU";
c45021f2
NC		 2098 case EM_386: return "Intel 80386";
2099 case EM_68K: return "MC68000";
2100 case EM_88K: return "MC88000";
22abe556 2101 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2102 case EM_860: return "Intel 80860";
2103 case EM_MIPS: return "MIPS R3000";
2104 case EM_S370: return "IBM System/370";
7036c0e1 2105 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2106 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2107 case EM_PARISC: return "HPPA";
252b5132 2108 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2109 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2110 case EM_960: return "Intel 90860";
2111 case EM_PPC: return "PowerPC";
285d1771 2112 case EM_PPC64: return "PowerPC64";
c45021f2 2113 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2114 case EM_FT32: return "FTDI FT32";
c45021f2 2115 case EM_RH32: return "TRW RH32";
b34976b6 2116 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2117 case EM_ARM: return "ARM";
2118 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2119 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2120 case EM_SPARCV9: return "Sparc v9";
2121 case EM_TRICORE: return "Siemens Tricore";
584da044 2122 case EM_ARC: return "ARC";
886a2506
NC		 2123 case EM_ARC_COMPACT: return "ARCompact";
2124 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2125 case EM_H8_300: return "Renesas H8/300";
2126 case EM_H8_300H: return "Renesas H8/300H";
2127 case EM_H8S: return "Renesas H8S";
2128 case EM_H8_500: return "Renesas H8/500";
30800947 2129 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2130 case EM_MIPS_X: return "Stanford MIPS-X";
2131 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2132 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2133 case EM_CYGNUS_D10V:
2134 case EM_D10V: return "d10v";
2135 case EM_CYGNUS_D30V:
b34976b6 2136 case EM_D30V: return "d30v";
2b0337b0 2137 case EM_CYGNUS_M32R:
26597c86 2138 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2139 case EM_CYGNUS_V850:
708e2187 2140 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2141 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2142 case EM_CYGNUS_MN10300:
2143 case EM_MN10300: return "mn10300";
2144 case EM_CYGNUS_MN10200:
2145 case EM_MN10200: return "mn10200";
5506d11a 2146 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2147 case EM_CYGNUS_FR30:
2148 case EM_FR30: return "Fujitsu FR30";
b34976b6 2149 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2150 case EM_PJ_OLD:
b34976b6 2151 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2152 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2153 case EM_PCP: return "Siemens PCP";
2154 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2155 case EM_NDR1: return "Denso NDR1 microprocesspr";
2156 case EM_STARCORE: return "Motorola Star*Core processor";
2157 case EM_ME16: return "Toyota ME16 processor";
2158 case EM_ST100: return "STMicroelectronics ST100 processor";
2159 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2160 case EM_PDSP: return "Sony DSP processor";
2161 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2162 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2163 case EM_FX66: return "Siemens FX66 microcontroller";
2164 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2166 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2167 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2168 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2169 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2170 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2171 case EM_SVX: return "Silicon Graphics SVx";
2172 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2173 case EM_VAX: return "Digital VAX";
619ed720 2174 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2175 case EM_AVR_OLD:
b34976b6 2176 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2177 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2178 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2179 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2180 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2181 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2182 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2183 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2184 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2185 case EM_L1OM: return "Intel L1OM";
7a9068fe 2186 case EM_K1OM: return "Intel K1OM";
b7498e0e 2187 case EM_S390_OLD:
b34976b6 2188 case EM_S390: return "IBM S/390";
1c0d3aa6 2189 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2190 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2191 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2192 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2193 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2194 case EM_DLX: return "OpenDLX";
1e4cf259 2195 case EM_IP2K_OLD:
b34976b6 2196 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2197 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2198 case EM_XTENSA_OLD:
2199 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2200 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2201 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2202 case EM_NS32K: return "National Semiconductor 32000 series";
2203 case EM_TPC: return "Tenor Network TPC processor";
2204 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2205 case EM_MAX: return "MAX Processor";
2206 case EM_CR: return "National Semiconductor CompactRISC";
2207 case EM_F2MC16: return "Fujitsu F2MC16";
2208 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2209 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2210 case EM_M32C_OLD:
49f58d10 2211 case EM_M32C: return "Renesas M32c";
d031aafb 2212 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2213 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2214 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2215 case EM_SEP: return "Sharp embedded microprocessor";
2216 case EM_ARCA: return "Arca RISC microprocessor";
2217 case EM_UNICORE: return "Unicore";
2218 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2219 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2220 case EM_NIOS32: return "Altera Nios";
2221 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2222 case EM_C166:
d70c5fc7 2223 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2224 case EM_M16C: return "Renesas M16C series microprocessors";
2225 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2226 case EM_CE: return "Freescale Communication Engine RISC core";
2227 case EM_TSK3000: return "Altium TSK3000 core";
2228 case EM_RS08: return "Freescale RS08 embedded processor";
2229 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2230 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2231 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2232 case EM_SE_C17: return "Seiko Epson C17 family";
2233 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2234 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2235 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2236 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2238 case EM_R32C: return "Renesas R32C series microprocessors";
2239 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2240 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2241 case EM_8051: return "Intel 8051 and variants";
2242 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2243 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2244 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2245 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2247 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2248 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2249 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2250 case EM_CR16:
f6c1a2d5 2251 case EM_MICROBLAZE:
7ba29e2a 2252 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2253 case EM_RL78: return "Renesas RL78";
c7927a3c 2254 case EM_RX: return "Renesas RX";
a3c62988 2255 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2256 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2257 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2258 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2259 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2260 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2261 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2262 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2263 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2264 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2265 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2266 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2267 default:
35d9dd2f 2268 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2269 return buff;
2270 }
2271}
2272
f3485b74 2273static void
d3ba0551 2274decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2275{
2276 unsigned eabi;
2277 int unknown = 0;
2278
2279 eabi = EF_ARM_EABI_VERSION (e_flags);
2280 e_flags &= ~ EF_ARM_EABIMASK;
2281
2282 /* Handle "generic" ARM flags. */
2283 if (e_flags & EF_ARM_RELEXEC)
2284 {
2285 strcat (buf, ", relocatable executable");
2286 e_flags &= ~ EF_ARM_RELEXEC;
2287 }
76da6bbe 2288
f3485b74
NC		 2289 /* Now handle EABI specific flags. */
2290 switch (eabi)
2291 {
2292 default:
2c71103e 2293 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2294 if (e_flags)
2295 unknown = 1;
2296 break;
2297
2298 case EF_ARM_EABI_VER1:
a5bcd848 2299 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2300 while (e_flags)
2301 {
2302 unsigned flag;
76da6bbe 2303
f3485b74
NC		 2304 /* Process flags one bit at a time. */
2305 flag = e_flags & - e_flags;
2306 e_flags &= ~ flag;
76da6bbe 2307
f3485b74
NC		 2308 switch (flag)
2309 {
a5bcd848 2310 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2311 strcat (buf, ", sorted symbol tables");
2312 break;
76da6bbe 2313
f3485b74
NC		 2314 default:
2315 unknown = 1;
2316 break;
2317 }
2318 }
2319 break;
76da6bbe 2320
a5bcd848
PB		 2321 case EF_ARM_EABI_VER2:
2322 strcat (buf, ", Version2 EABI");
2323 while (e_flags)
2324 {
2325 unsigned flag;
2326
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2329 e_flags &= ~ flag;
2330
2331 switch (flag)
2332 {
2333 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf, ", sorted symbol tables");
2335 break;
2336
2337 case EF_ARM_DYNSYMSUSESEGIDX:
2338 strcat (buf, ", dynamic symbols use segment index");
2339 break;
2340
2341 case EF_ARM_MAPSYMSFIRST:
2342 strcat (buf, ", mapping symbols precede others");
2343 break;
2344
2345 default:
2346 unknown = 1;
2347 break;
2348 }
2349 }
2350 break;
2351
d507cf36
PB		 2352 case EF_ARM_EABI_VER3:
2353 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2354 break;
2355
2356 case EF_ARM_EABI_VER4:
2357 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2358 while (e_flags)
2359 {
2360 unsigned flag;
2361
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2364 e_flags &= ~ flag;
2365
2366 switch (flag)
2367 {
2368 case EF_ARM_BE8:
2369 strcat (buf, ", BE8");
2370 break;
2371
2372 case EF_ARM_LE8:
2373 strcat (buf, ", LE8");
2374 break;
2375
2376 default:
2377 unknown = 1;
2378 break;
2379 }
2380 break;
2381 }
2382 break;
3a4a14e9
PB		 2383
2384 case EF_ARM_EABI_VER5:
2385 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2386 while (e_flags)
2387 {
2388 unsigned flag;
2389
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2392 e_flags &= ~ flag;
2393
2394 switch (flag)
2395 {
2396 case EF_ARM_BE8:
2397 strcat (buf, ", BE8");
2398 break;
2399
2400 case EF_ARM_LE8:
2401 strcat (buf, ", LE8");
2402 break;
2403
3bfcb652
NC		 2404 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf, ", soft-float ABI");
2406 break;
2407
2408 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf, ", hard-float ABI");
2410 break;
2411
d507cf36
PB		 2412 default:
2413 unknown = 1;
2414 break;
2415 }
2416 }
2417 break;
2418
f3485b74 2419 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2420 strcat (buf, ", GNU EABI");
f3485b74
NC		 2421 while (e_flags)
2422 {
2423 unsigned flag;
76da6bbe 2424
f3485b74
NC		 2425 /* Process flags one bit at a time. */
2426 flag = e_flags & - e_flags;
2427 e_flags &= ~ flag;
76da6bbe 2428
f3485b74
NC		 2429 switch (flag)
2430 {
a5bcd848 2431 case EF_ARM_INTERWORK:
f3485b74
NC		 2432 strcat (buf, ", interworking enabled");
2433 break;
76da6bbe 2434
a5bcd848 2435 case EF_ARM_APCS_26:
f3485b74
NC		 2436 strcat (buf, ", uses APCS/26");
2437 break;
76da6bbe 2438
a5bcd848 2439 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2440 strcat (buf, ", uses APCS/float");
2441 break;
76da6bbe 2442
a5bcd848 2443 case EF_ARM_PIC:
f3485b74
NC		 2444 strcat (buf, ", position independent");
2445 break;
76da6bbe 2446
a5bcd848 2447 case EF_ARM_ALIGN8:
f3485b74
NC		 2448 strcat (buf, ", 8 bit structure alignment");
2449 break;
76da6bbe 2450
a5bcd848 2451 case EF_ARM_NEW_ABI:
f3485b74
NC		 2452 strcat (buf, ", uses new ABI");
2453 break;
76da6bbe 2454
a5bcd848 2455 case EF_ARM_OLD_ABI:
f3485b74
NC		 2456 strcat (buf, ", uses old ABI");
2457 break;
76da6bbe 2458
a5bcd848 2459 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2460 strcat (buf, ", software FP");
2461 break;
76da6bbe 2462
90e01f86
ILT		 2463 case EF_ARM_VFP_FLOAT:
2464 strcat (buf, ", VFP");
2465 break;
2466
fde78edd
NC		 2467 case EF_ARM_MAVERICK_FLOAT:
2468 strcat (buf, ", Maverick FP");
2469 break;
2470
f3485b74
NC		 2471 default:
2472 unknown = 1;
2473 break;
2474 }
2475 }
2476 }
f3485b74
NC		 2477
2478 if (unknown)
2b692964 2479 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2480}
2481
343433df
AB		 2482static void
2483decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2484{
2485 --size; /* Leave space for null terminator. */
2486
2487 switch (e_flags & EF_AVR_MACH)
2488 {
2489 case E_AVR_MACH_AVR1:
2490 strncat (buf, ", avr:1", size);
2491 break;
2492 case E_AVR_MACH_AVR2:
2493 strncat (buf, ", avr:2", size);
2494 break;
2495 case E_AVR_MACH_AVR25:
2496 strncat (buf, ", avr:25", size);
2497 break;
2498 case E_AVR_MACH_AVR3:
2499 strncat (buf, ", avr:3", size);
2500 break;
2501 case E_AVR_MACH_AVR31:
2502 strncat (buf, ", avr:31", size);
2503 break;
2504 case E_AVR_MACH_AVR35:
2505 strncat (buf, ", avr:35", size);
2506 break;
2507 case E_AVR_MACH_AVR4:
2508 strncat (buf, ", avr:4", size);
2509 break;
2510 case E_AVR_MACH_AVR5:
2511 strncat (buf, ", avr:5", size);
2512 break;
2513 case E_AVR_MACH_AVR51:
2514 strncat (buf, ", avr:51", size);
2515 break;
2516 case E_AVR_MACH_AVR6:
2517 strncat (buf, ", avr:6", size);
2518 break;
2519 case E_AVR_MACH_AVRTINY:
2520 strncat (buf, ", avr:100", size);
2521 break;
2522 case E_AVR_MACH_XMEGA1:
2523 strncat (buf, ", avr:101", size);
2524 break;
2525 case E_AVR_MACH_XMEGA2:
2526 strncat (buf, ", avr:102", size);
2527 break;
2528 case E_AVR_MACH_XMEGA3:
2529 strncat (buf, ", avr:103", size);
2530 break;
2531 case E_AVR_MACH_XMEGA4:
2532 strncat (buf, ", avr:104", size);
2533 break;
2534 case E_AVR_MACH_XMEGA5:
2535 strncat (buf, ", avr:105", size);
2536 break;
2537 case E_AVR_MACH_XMEGA6:
2538 strncat (buf, ", avr:106", size);
2539 break;
2540 case E_AVR_MACH_XMEGA7:
2541 strncat (buf, ", avr:107", size);
2542 break;
2543 default:
2544 strncat (buf, ", avr:<unknown>", size);
2545 break;
2546 }
2547
2548 size -= strlen (buf);
2549 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550 strncat (buf, ", link-relax", size);
2551}
2552
35c08157
KLC		 2553static void
2554decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2555{
2556 unsigned abi;
2557 unsigned arch;
2558 unsigned config;
2559 unsigned version;
2560 int has_fpu = 0;
2561 int r = 0;
2562
2563 static const char *ABI_STRINGS[] =
2564 {
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2569 "AABI",
2570 "ABI2 FP+"
35c08157
KLC		 2571 };
2572 static const char *VER_STRINGS[] =
2573 {
2574 "Andes ELF V1.3 or older",
2575 "Andes ELF V1.3.1",
2576 "Andes ELF V1.4"
2577 };
2578 static const char *ARCH_STRINGS[] =
2579 {
2580 "",
2581 "Andes Star v1.0",
2582 "Andes Star v2.0",
2583 "Andes Star v3.0",
2584 "Andes Star v3.0m"
2585 };
2586
2587 abi = EF_NDS_ABI & e_flags;
2588 arch = EF_NDS_ARCH & e_flags;
2589 config = EF_NDS_INST & e_flags;
2590 version = EF_NDS32_ELF_VERSION & e_flags;
2591
2592 memset (buf, 0, size);
2593
2594 switch (abi)
2595 {
2596 case E_NDS_ABI_V0:
2597 case E_NDS_ABI_V1:
2598 case E_NDS_ABI_V2:
2599 case E_NDS_ABI_V2FP:
2600 case E_NDS_ABI_AABI:
40c7a7cb 2601 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2602 /* In case there are holes in the array. */
2603 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2604 break;
2605
2606 default:
2607 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2608 break;
2609 }
2610
2611 switch (version)
2612 {
2613 case E_NDS32_ELF_VER_1_2:
2614 case E_NDS32_ELF_VER_1_3:
2615 case E_NDS32_ELF_VER_1_4:
2616 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2617 break;
2618
2619 default:
2620 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2621 break;
2622 }
2623
2624 if (E_NDS_ABI_V0 == abi)
2625 {
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch == E_NDS_ARCH_STAR_V1_0)
2629 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2630 return;
2631 }
2632
2633 switch (arch)
2634 {
2635 case E_NDS_ARCH_STAR_V1_0:
2636 case E_NDS_ARCH_STAR_V2_0:
2637 case E_NDS_ARCH_STAR_V3_0:
2638 case E_NDS_ARCH_STAR_V3_M:
2639 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2640 break;
2641
2642 default:
2643 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2646 return;
2647 }
2648
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch == E_NDS_ARCH_STAR_V1_0)
2651 {
2652 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2654
2655 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656 r += snprintf (buf + r, size -r, ", MAC");
2657
2658 if (config & E_NDS32_HAS_DIV_INST)
2659 r += snprintf (buf + r, size -r, ", DIV");
2660
2661 if (config & E_NDS32_HAS_16BIT_INST)
2662 r += snprintf (buf + r, size -r, ", 16b");
2663 }
2664 else
2665 {
2666 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2667 {
2668 if (version <= E_NDS32_ELF_VER_1_3)
2669 r += snprintf (buf + r, size -r, ", [B8]");
2670 else
2671 r += snprintf (buf + r, size -r, ", EX9");
2672 }
2673
2674 if (config & E_NDS32_HAS_MAC_DX_INST)
2675 r += snprintf (buf + r, size -r, ", MAC_DX");
2676
2677 if (config & E_NDS32_HAS_DIV_DX_INST)
2678 r += snprintf (buf + r, size -r, ", DIV_DX");
2679
2680 if (config & E_NDS32_HAS_16BIT_INST)
2681 {
2682 if (version <= E_NDS32_ELF_VER_1_3)
2683 r += snprintf (buf + r, size -r, ", 16b");
2684 else
2685 r += snprintf (buf + r, size -r, ", IFC");
2686 }
2687 }
2688
2689 if (config & E_NDS32_HAS_EXT_INST)
2690 r += snprintf (buf + r, size -r, ", PERF1");
2691
2692 if (config & E_NDS32_HAS_EXT2_INST)
2693 r += snprintf (buf + r, size -r, ", PERF2");
2694
2695 if (config & E_NDS32_HAS_FPU_INST)
2696 {
2697 has_fpu = 1;
2698 r += snprintf (buf + r, size -r, ", FPU_SP");
2699 }
2700
2701 if (config & E_NDS32_HAS_FPU_DP_INST)
2702 {
2703 has_fpu = 1;
2704 r += snprintf (buf + r, size -r, ", FPU_DP");
2705 }
2706
2707 if (config & E_NDS32_HAS_FPU_MAC_INST)
2708 {
2709 has_fpu = 1;
2710 r += snprintf (buf + r, size -r, ", FPU_MAC");
2711 }
2712
2713 if (has_fpu)
2714 {
2715 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2716 {
2717 case E_NDS32_FPU_REG_8SP_4DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2719 break;
2720 case E_NDS32_FPU_REG_16SP_8DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2722 break;
2723 case E_NDS32_FPU_REG_32SP_16DP:
2724 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2725 break;
2726 case E_NDS32_FPU_REG_32SP_32DP:
2727 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2728 break;
2729 }
2730 }
2731
2732 if (config & E_NDS32_HAS_AUDIO_INST)
2733 r += snprintf (buf + r, size -r, ", AUDIO");
2734
2735 if (config & E_NDS32_HAS_STRING_INST)
2736 r += snprintf (buf + r, size -r, ", STR");
2737
2738 if (config & E_NDS32_HAS_REDUCED_REGS)
2739 r += snprintf (buf + r, size -r, ", 16REG");
2740
2741 if (config & E_NDS32_HAS_VIDEO_INST)
2742 {
2743 if (version <= E_NDS32_ELF_VER_1_3)
2744 r += snprintf (buf + r, size -r, ", VIDEO");
2745 else
2746 r += snprintf (buf + r, size -r, ", SATURATION");
2747 }
2748
2749 if (config & E_NDS32_HAS_ENCRIPT_INST)
2750 r += snprintf (buf + r, size -r, ", ENCRP");
2751
2752 if (config & E_NDS32_HAS_L2C_INST)
2753 r += snprintf (buf + r, size -r, ", L2C");
2754}
2755
252b5132 2756static char *
d3ba0551 2757get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2758{
b34976b6 2759 static char buf[1024];
252b5132
RH		 2760
2761 buf[0] = '\0';
76da6bbe 2762
252b5132
RH		 2763 if (e_flags)
2764 {
2765 switch (e_machine)
2766 {
2767 default:
2768 break;
2769
886a2506
NC		 2770 case EM_ARC_COMPACT2:
2771 switch (e_flags & EF_ARC_MACH_MSK)
2772 {
2773 case EF_ARC_CPU_ARCV2EM:
2774 strcat (buf, ", ARC EM");
2775 break;
2776 case EF_ARC_CPU_ARCV2HS:
2777 strcat (buf, ", ARC HS");
2778 break;
2779 default:
2780 strcat (buf, ", unrecognized flag for ARCv2");
2781 break;
2782 }
2783 switch (e_flags & EF_ARC_OSABI_MSK)
2784 {
2785 /* Only upstream 3.9+ kernels will support ARCv2
2786 ISA. */
2787 case E_ARC_OSABI_V3:
2788 strcat (buf, ", v3 no-legacy-syscalls ABI");
2789 break;
2790 }
2791 break;
2792
2793 case EM_ARC_COMPACT:
2794 switch (e_flags & EF_ARC_MACH_MSK)
2795 {
2796 case E_ARC_MACH_ARC600:
2797 strcat (buf, ", ARC 600");
2798 break;
2799 case E_ARC_MACH_ARC601:
2800 strcat (buf, ", ARC 601");
2801 break;
2802 case E_ARC_MACH_ARC700:
2803 strcat (buf, ", ARC 700");
2804 break;
2805 default:
2806 strcat (buf, ", Generic ARCompact");
2807 break;
2808 }
2809 switch (e_flags & EF_ARC_OSABI_MSK)
2810 {
2811 case E_ARC_OSABI_ORIG:
2812 strcat (buf, ", legacy syscall ABI");
2813 break;
2814 case E_ARC_OSABI_V2:
2815 /* For 3.2+ Linux kernels which use asm-generic
2816 hdrs. */
2817 strcat (buf, ", v2 syscall ABI");
2818 break;
2819 case E_ARC_OSABI_V3:
2820 /* Upstream 3.9+ kernels which don't use any legacy
2821 syscalls. */
2822 strcat (buf, ", v3 no-legacy-syscalls ABI");
2823 break;
2824 }
2825 break;
2826
f3485b74
NC		 2827 case EM_ARM:
2828 decode_ARM_machine_flags (e_flags, buf);
2829 break;
76da6bbe 2830
343433df
AB		 2831 case EM_AVR:
2832 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2833 break;
2834
781303ce
MF		 2835 case EM_BLACKFIN:
2836 if (e_flags & EF_BFIN_PIC)
2837 strcat (buf, ", PIC");
2838
2839 if (e_flags & EF_BFIN_FDPIC)
2840 strcat (buf, ", FDPIC");
2841
2842 if (e_flags & EF_BFIN_CODE_IN_L1)
2843 strcat (buf, ", code in L1");
2844
2845 if (e_flags & EF_BFIN_DATA_IN_L1)
2846 strcat (buf, ", data in L1");
2847
2848 break;
2849
ec2dfb42
AO		 2850 case EM_CYGNUS_FRV:
2851 switch (e_flags & EF_FRV_CPU_MASK)
2852 {
2853 case EF_FRV_CPU_GENERIC:
2854 break;
2855
2856 default:
2857 strcat (buf, ", fr???");
2858 break;
57346661 2859
ec2dfb42
AO		 2860 case EF_FRV_CPU_FR300:
2861 strcat (buf, ", fr300");
2862 break;
2863
2864 case EF_FRV_CPU_FR400:
2865 strcat (buf, ", fr400");
2866 break;
2867 case EF_FRV_CPU_FR405:
2868 strcat (buf, ", fr405");
2869 break;
2870
2871 case EF_FRV_CPU_FR450:
2872 strcat (buf, ", fr450");
2873 break;
2874
2875 case EF_FRV_CPU_FR500:
2876 strcat (buf, ", fr500");
2877 break;
2878 case EF_FRV_CPU_FR550:
2879 strcat (buf, ", fr550");
2880 break;
2881
2882 case EF_FRV_CPU_SIMPLE:
2883 strcat (buf, ", simple");
2884 break;
2885 case EF_FRV_CPU_TOMCAT:
2886 strcat (buf, ", tomcat");
2887 break;
2888 }
1c877e87 2889 break;
ec2dfb42 2890
53c7db4b 2891 case EM_68K:
425c6cb0 2892 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2893 strcat (buf, ", m68000");
425c6cb0 2894 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2895 strcat (buf, ", cpu32");
2896 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2897 strcat (buf, ", fido_a");
425c6cb0 2898 else
266abb8f 2899 {
2cf0635d
NC		 2900 char const * isa = _("unknown");
2901 char const * mac = _("unknown mac");
2902 char const * additional = NULL;
0112cd26 2903
c694fd50 2904 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2905 {
c694fd50 2906 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2907 isa = "A";
2908 additional = ", nodiv";
2909 break;
c694fd50 2910 case EF_M68K_CF_ISA_A:
266abb8f
NS		 2911 isa = "A";
2912 break;
c694fd50 2913 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 2914 isa = "A+";
2915 break;
c694fd50 2916 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 2917 isa = "B";
2918 additional = ", nousp";
2919 break;
c694fd50 2920 case EF_M68K_CF_ISA_B:
266abb8f
NS		 2921 isa = "B";
2922 break;
f608cd77
NS		 2923 case EF_M68K_CF_ISA_C:
2924 isa = "C";
2925 break;
2926 case EF_M68K_CF_ISA_C_NODIV:
2927 isa = "C";
2928 additional = ", nodiv";
2929 break;
266abb8f
NS		 2930 }
2931 strcat (buf, ", cf, isa ");
2932 strcat (buf, isa);
0b2e31dc
NS		 2933 if (additional)
2934 strcat (buf, additional);
c694fd50 2935 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 2936 strcat (buf, ", float");
c694fd50 2937 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 2938 {
2939 case 0:
2940 mac = NULL;
2941 break;
c694fd50 2942 case EF_M68K_CF_MAC:
266abb8f
NS		 2943 mac = "mac";
2944 break;
c694fd50 2945 case EF_M68K_CF_EMAC:
266abb8f
NS		 2946 mac = "emac";
2947 break;
f608cd77
NS		 2948 case EF_M68K_CF_EMAC_B:
2949 mac = "emac_b";
2950 break;
266abb8f
NS		 2951 }
2952 if (mac)
2953 {
2954 strcat (buf, ", ");
2955 strcat (buf, mac);
2956 }
266abb8f 2957 }
53c7db4b 2958 break;
33c63f9d 2959
153a2776
NC		 2960 case EM_CYGNUS_MEP:
2961 switch (e_flags & EF_MEP_CPU_MASK)
2962 {
2963 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
2964 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
2965 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
2966 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
2967 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
2968 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
2969 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
2970 }
2971
2972 switch (e_flags & EF_MEP_COP_MASK)
2973 {
2974 case EF_MEP_COP_NONE: break;
2975 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
2976 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
2977 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
2978 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
2979 default: strcat (buf, _("<unknown MeP copro type>")); break;
2980 }
2981
2982 if (e_flags & EF_MEP_LIBRARY)
2983 strcat (buf, ", Built for Library");
2984
2985 if (e_flags & EF_MEP_INDEX_MASK)
2986 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
2987 e_flags & EF_MEP_INDEX_MASK);
2988
2989 if (e_flags & ~ EF_MEP_ALL_FLAGS)
2990 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
2991 e_flags & ~ EF_MEP_ALL_FLAGS);
2992 break;
2993
252b5132
RH		 2994 case EM_PPC:
2995 if (e_flags & EF_PPC_EMB)
2996 strcat (buf, ", emb");
2997
2998 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 2999 strcat (buf, _(", relocatable"));
252b5132
RH		 3000
3001 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3002 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3003 break;
3004
ee67d69a
AM		 3005 case EM_PPC64:
3006 if (e_flags & EF_PPC64_ABI)
3007 {
3008 char abi[] = ", abiv0";
3009
3010 abi[6] += e_flags & EF_PPC64_ABI;
3011 strcat (buf, abi);
3012 }
3013 break;
3014
708e2187
NC		 3015 case EM_V800:
3016 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3017 strcat (buf, ", RH850 ABI");
0b4362b0 3018
708e2187
NC		 3019 if (e_flags & EF_V800_850E3)
3020 strcat (buf, ", V3 architecture");
3021
3022 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3023 strcat (buf, ", FPU not used");
3024
3025 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3026 strcat (buf, ", regmode: COMMON");
3027
3028 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3029 strcat (buf, ", r4 not used");
3030
3031 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3032 strcat (buf, ", r30 not used");
3033
3034 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3035 strcat (buf, ", r5 not used");
3036
3037 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3038 strcat (buf, ", r2 not used");
3039
3040 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3041 {
3042 switch (e_flags & - e_flags)
3043 {
3044 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3045 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3046 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3047 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3048 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3049 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3050 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3051 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3052 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3053 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3054 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3055 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3056 default: break;
3057 }
3058 }
3059 break;
3060
2b0337b0 3061 case EM_V850:
252b5132
RH		 3062 case EM_CYGNUS_V850:
3063 switch (e_flags & EF_V850_ARCH)
3064 {
78c8d46c
NC		 3065 case E_V850E3V5_ARCH:
3066 strcat (buf, ", v850e3v5");
3067 break;
1cd986c5
NC		 3068 case E_V850E2V3_ARCH:
3069 strcat (buf, ", v850e2v3");
3070 break;
3071 case E_V850E2_ARCH:
3072 strcat (buf, ", v850e2");
3073 break;
3074 case E_V850E1_ARCH:
3075 strcat (buf, ", v850e1");
8ad30312 3076 break;
252b5132
RH		 3077 case E_V850E_ARCH:
3078 strcat (buf, ", v850e");
3079 break;
252b5132
RH		 3080 case E_V850_ARCH:
3081 strcat (buf, ", v850");
3082 break;
3083 default:
2b692964 3084 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3085 break;
3086 }
3087 break;
3088
2b0337b0 3089 case EM_M32R:
252b5132
RH		 3090 case EM_CYGNUS_M32R:
3091 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3092 strcat (buf, ", m32r");
252b5132
RH		 3093 break;
3094
3095 case EM_MIPS:
4fe85591 3096 case EM_MIPS_RS3_LE:
252b5132
RH		 3097 if (e_flags & EF_MIPS_NOREORDER)
3098 strcat (buf, ", noreorder");
3099
3100 if (e_flags & EF_MIPS_PIC)
3101 strcat (buf, ", pic");
3102
3103 if (e_flags & EF_MIPS_CPIC)
3104 strcat (buf, ", cpic");
3105
d1bdd336
TS		 3106 if (e_flags & EF_MIPS_UCODE)
3107 strcat (buf, ", ugen_reserved");
3108
252b5132
RH		 3109 if (e_flags & EF_MIPS_ABI2)
3110 strcat (buf, ", abi2");
3111
43521d43
TS		 3112 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3113 strcat (buf, ", odk first");
3114
a5d22d2a
TS		 3115 if (e_flags & EF_MIPS_32BITMODE)
3116 strcat (buf, ", 32bitmode");
3117
ba92f887
MR		 3118 if (e_flags & EF_MIPS_NAN2008)
3119 strcat (buf, ", nan2008");
3120
fef1b0b3
SE		 3121 if (e_flags & EF_MIPS_FP64)
3122 strcat (buf, ", fp64");
3123
156c2f8b
NC		 3124 switch ((e_flags & EF_MIPS_MACH))
3125 {
3126 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3127 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3128 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3129 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3130 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3131 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3132 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3133 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3134 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3135 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3136 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3137 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3138 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3139 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3140 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3141 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3142 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3143 case 0:
3144 /* We simply ignore the field in this case to avoid confusion:
3145 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3146 extension. */
3147 break;
2b692964 3148 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3149 }
43521d43
TS		 3150
3151 switch ((e_flags & EF_MIPS_ABI))
3152 {
3153 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3154 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3155 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3156 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3157 case 0:
3158 /* We simply ignore the field in this case to avoid confusion:
3159 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3160 This means it is likely to be an o32 file, but not for
3161 sure. */
3162 break;
2b692964 3163 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3164 }
3165
3166 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3167 strcat (buf, ", mdmx");
3168
3169 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3170 strcat (buf, ", mips16");
3171
df58fc94
RS		 3172 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3173 strcat (buf, ", micromips");
3174
43521d43
TS		 3175 switch ((e_flags & EF_MIPS_ARCH))
3176 {
3177 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3178 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3179 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3180 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3181 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3182 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3183 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3184 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3185 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3186 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3187 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3188 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3189 }
252b5132 3190 break;
351b4b40 3191
35c08157
KLC		 3192 case EM_NDS32:
3193 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3194 break;
3195
ccde1100
AO		 3196 case EM_SH:
3197 switch ((e_flags & EF_SH_MACH_MASK))
3198 {
3199 case EF_SH1: strcat (buf, ", sh1"); break;
3200 case EF_SH2: strcat (buf, ", sh2"); break;
3201 case EF_SH3: strcat (buf, ", sh3"); break;
3202 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3203 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3204 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3205 case EF_SH3E: strcat (buf, ", sh3e"); break;
3206 case EF_SH4: strcat (buf, ", sh4"); break;
3207 case EF_SH5: strcat (buf, ", sh5"); break;
3208 case EF_SH2E: strcat (buf, ", sh2e"); break;
3209 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3210 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3211 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3212 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3213 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3214 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3215 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3216 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3217 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3218 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3219 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3220 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3221 }
3222
cec6a5b8
MR		 3223 if (e_flags & EF_SH_PIC)
3224 strcat (buf, ", pic");
3225
3226 if (e_flags & EF_SH_FDPIC)
3227 strcat (buf, ", fdpic");
ccde1100 3228 break;
948f632f 3229
73589c9d
CS		 3230 case EM_OR1K:
3231 if (e_flags & EF_OR1K_NODELAY)
3232 strcat (buf, ", no delay");
3233 break;
57346661 3234
351b4b40
RH		 3235 case EM_SPARCV9:
3236 if (e_flags & EF_SPARC_32PLUS)
3237 strcat (buf, ", v8+");
3238
3239 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3240 strcat (buf, ", ultrasparcI");
3241
3242 if (e_flags & EF_SPARC_SUN_US3)
3243 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3244
3245 if (e_flags & EF_SPARC_HAL_R1)
3246 strcat (buf, ", halr1");
3247
3248 if (e_flags & EF_SPARC_LEDATA)
3249 strcat (buf, ", ledata");
3250
3251 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3252 strcat (buf, ", tso");
3253
3254 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3255 strcat (buf, ", pso");
3256
3257 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3258 strcat (buf, ", rmo");
3259 break;
7d466069 3260
103f02d3
UD		 3261 case EM_PARISC:
3262 switch (e_flags & EF_PARISC_ARCH)
3263 {
3264 case EFA_PARISC_1_0:
3265 strcpy (buf, ", PA-RISC 1.0");
3266 break;
3267 case EFA_PARISC_1_1:
3268 strcpy (buf, ", PA-RISC 1.1");
3269 break;
3270 case EFA_PARISC_2_0:
3271 strcpy (buf, ", PA-RISC 2.0");
3272 break;
3273 default:
3274 break;
3275 }
3276 if (e_flags & EF_PARISC_TRAPNIL)
3277 strcat (buf, ", trapnil");
3278 if (e_flags & EF_PARISC_EXT)
3279 strcat (buf, ", ext");
3280 if (e_flags & EF_PARISC_LSB)
3281 strcat (buf, ", lsb");
3282 if (e_flags & EF_PARISC_WIDE)
3283 strcat (buf, ", wide");
3284 if (e_flags & EF_PARISC_NO_KABP)
3285 strcat (buf, ", no kabp");
3286 if (e_flags & EF_PARISC_LAZYSWAP)
3287 strcat (buf, ", lazyswap");
30800947 3288 break;
76da6bbe 3289
7d466069 3290 case EM_PJ:
2b0337b0 3291 case EM_PJ_OLD:
7d466069
ILT		 3292 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3293 strcat (buf, ", new calling convention");
3294
3295 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3296 strcat (buf, ", gnu calling convention");
3297 break;
4d6ed7c8
NC		 3298
3299 case EM_IA_64:
3300 if ((e_flags & EF_IA_64_ABI64))
3301 strcat (buf, ", 64-bit");
3302 else
3303 strcat (buf, ", 32-bit");
3304 if ((e_flags & EF_IA_64_REDUCEDFP))
3305 strcat (buf, ", reduced fp model");
3306 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3307 strcat (buf, ", no function descriptors, constant gp");
3308 else if ((e_flags & EF_IA_64_CONS_GP))
3309 strcat (buf, ", constant gp");
3310 if ((e_flags & EF_IA_64_ABSOLUTE))
3311 strcat (buf, ", absolute");
28f997cf
TG		 3312 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3313 {
3314 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3315 strcat (buf, ", vms_linkages");
3316 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3317 {
3318 case EF_IA_64_VMS_COMCOD_SUCCESS:
3319 break;
3320 case EF_IA_64_VMS_COMCOD_WARNING:
3321 strcat (buf, ", warning");
3322 break;
3323 case EF_IA_64_VMS_COMCOD_ERROR:
3324 strcat (buf, ", error");
3325 break;
3326 case EF_IA_64_VMS_COMCOD_ABORT:
3327 strcat (buf, ", abort");
3328 break;
3329 default:
bee0ee85
NC		 3330 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3331 e_flags & EF_IA_64_VMS_COMCOD);
3332 strcat (buf, ", <unknown>");
28f997cf
TG		 3333 }
3334 }
4d6ed7c8 3335 break;
179d3252
JT		 3336
3337 case EM_VAX:
3338 if ((e_flags & EF_VAX_NONPIC))
3339 strcat (buf, ", non-PIC");
3340 if ((e_flags & EF_VAX_DFLOAT))
3341 strcat (buf, ", D-Float");
3342 if ((e_flags & EF_VAX_GFLOAT))
3343 strcat (buf, ", G-Float");
3344 break;
c7927a3c 3345
619ed720
EB		 3346 case EM_VISIUM:
3347 if (e_flags & EF_VISIUM_ARCH_MCM)
3348 strcat (buf, ", mcm");
3349 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3350 strcat (buf, ", mcm24");
3351 if (e_flags & EF_VISIUM_ARCH_GR6)
3352 strcat (buf, ", gr6");
3353 break;
3354
4046d87a 3355 case EM_RL78:
1740ba0c
NC		 3356 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3357 {
3358 case E_FLAG_RL78_ANY_CPU: break;
3359 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3360 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3361 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3362 }
856ea05c
KP		 3363 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3364 strcat (buf, ", 64-bit doubles");
4046d87a 3365 break;
0b4362b0 3366
c7927a3c
NC		 3367 case EM_RX:
3368 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3369 strcat (buf, ", 64-bit doubles");
3370 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3371 strcat (buf, ", dsp");
d4cb0ea0 3372 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3373 strcat (buf, ", pid");
708e2187
NC		 3374 if (e_flags & E_FLAG_RX_ABI)
3375 strcat (buf, ", RX ABI");
3525236c
NC		 3376 if (e_flags & E_FLAG_RX_SINSNS_SET)
3377 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3378 ? ", uses String instructions" : ", bans String instructions");
d4cb0ea0 3379 break;
55786da2
AK		 3380
3381 case EM_S390:
3382 if (e_flags & EF_S390_HIGH_GPRS)
3383 strcat (buf, ", highgprs");
d4cb0ea0 3384 break;
40b36596
JM		 3385
3386 case EM_TI_C6000:
3387 if ((e_flags & EF_C6000_REL))
3388 strcat (buf, ", relocatable module");
d4cb0ea0 3389 break;
13761a11
NC		 3390
3391 case EM_MSP430:
3392 strcat (buf, _(": architecture variant: "));
3393 switch (e_flags & EF_MSP430_MACH)
3394 {
3395 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3396 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3397 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3398 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3399 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3400 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3401 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3402 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3403 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3404 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3405 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3406 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3407 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3408 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3409 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3410 default:
3411 strcat (buf, _(": unknown")); break;
3412 }
3413
3414 if (e_flags & ~ EF_MSP430_MACH)
3415 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3416 }
3417 }
3418
3419 return buf;
3420}
3421
252b5132 3422static const char *
d3ba0551
AM		 3423get_osabi_name (unsigned int osabi)
3424{
3425 static char buff[32];
3426
3427 switch (osabi)
3428 {
3429 case ELFOSABI_NONE: return "UNIX - System V";
3430 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3431 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3432 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3433 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3434 case ELFOSABI_AIX: return "UNIX - AIX";
3435 case ELFOSABI_IRIX: return "UNIX - IRIX";
3436 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3437 case ELFOSABI_TRU64: return "UNIX - TRU64";
3438 case ELFOSABI_MODESTO: return "Novell - Modesto";
3439 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3440 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3441 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3442 case ELFOSABI_AROS: return "AROS";
11636f9e 3443 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3444 default:
40b36596
JM		 3445 if (osabi >= 64)
3446 switch (elf_header.e_machine)
3447 {
3448 case EM_ARM:
3449 switch (osabi)
3450 {
3451 case ELFOSABI_ARM: return "ARM";
3452 default:
3453 break;
3454 }
3455 break;
3456
3457 case EM_MSP430:
3458 case EM_MSP430_OLD:
619ed720 3459 case EM_VISIUM:
40b36596
JM		 3460 switch (osabi)
3461 {
3462 case ELFOSABI_STANDALONE: return _("Standalone App");
3463 default:
3464 break;
3465 }
3466 break;
3467
3468 case EM_TI_C6000:
3469 switch (osabi)
3470 {
3471 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3472 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3473 default:
3474 break;
3475 }
3476 break;
3477
3478 default:
3479 break;
3480 }
e9e44622 3481 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3482 return buff;
3483 }
3484}
3485
a06ea964
NC		 3486static const char *
3487get_aarch64_segment_type (unsigned long type)
3488{
3489 switch (type)
3490 {
3491 case PT_AARCH64_ARCHEXT:
3492 return "AARCH64_ARCHEXT";
3493 default:
3494 break;
3495 }
3496
3497 return NULL;
3498}
3499
b294bdf8
MM		 3500static const char *
3501get_arm_segment_type (unsigned long type)
3502{
3503 switch (type)
3504 {
3505 case PT_ARM_EXIDX:
3506 return "EXIDX";
3507 default:
3508 break;
3509 }
3510
3511 return NULL;
3512}
3513
d3ba0551
AM		 3514static const char *
3515get_mips_segment_type (unsigned long type)
252b5132
RH		 3516{
3517 switch (type)
3518 {
3519 case PT_MIPS_REGINFO:
3520 return "REGINFO";
3521 case PT_MIPS_RTPROC:
3522 return "RTPROC";
3523 case PT_MIPS_OPTIONS:
3524 return "OPTIONS";
351cdf24
MF		 3525 case PT_MIPS_ABIFLAGS:
3526 return "ABIFLAGS";
252b5132
RH		 3527 default:
3528 break;
3529 }
3530
3531 return NULL;
3532}
3533
103f02d3 3534static const char *
d3ba0551 3535get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3536{
3537 switch (type)
3538 {
3539 case PT_HP_TLS: return "HP_TLS";
3540 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3541 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3542 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3543 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3544 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3545 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3546 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3547 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3548 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3549 case PT_HP_PARALLEL: return "HP_PARALLEL";
3550 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3551 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3552 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3553 case PT_HP_STACK: return "HP_STACK";
3554 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3555 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3556 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3557 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3558 default:
3559 break;
3560 }
3561
3562 return NULL;
3563}
3564
4d6ed7c8 3565static const char *
d3ba0551 3566get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3567{
3568 switch (type)
3569 {
3570 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3571 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3572 case PT_HP_TLS: return "HP_TLS";
3573 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3574 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3575 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3576 default:
3577 break;
3578 }
3579
3580 return NULL;
3581}
3582
40b36596
JM		 3583static const char *
3584get_tic6x_segment_type (unsigned long type)
3585{
3586 switch (type)
3587 {
3588 case PT_C6000_PHATTR: return "C6000_PHATTR";
3589 default:
3590 break;
3591 }
3592
3593 return NULL;
3594}
3595
252b5132 3596static const char *
d3ba0551 3597get_segment_type (unsigned long p_type)
252b5132 3598{
b34976b6 3599 static char buff[32];
252b5132
RH		 3600
3601 switch (p_type)
3602 {
b34976b6
AM		 3603 case PT_NULL: return "NULL";
3604 case PT_LOAD: return "LOAD";
252b5132 3605 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3606 case PT_INTERP: return "INTERP";
3607 case PT_NOTE: return "NOTE";
3608 case PT_SHLIB: return "SHLIB";
3609 case PT_PHDR: return "PHDR";
13ae64f3 3610 case PT_TLS: return "TLS";
252b5132 3611
65765700
JJ		 3612 case PT_GNU_EH_FRAME:
3613 return "GNU_EH_FRAME";
2b05f1b7 3614 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3615 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3616
252b5132
RH		 3617 default:
3618 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3619 {
2cf0635d 3620 const char * result;
103f02d3 3621
252b5132
RH		 3622 switch (elf_header.e_machine)
3623 {
a06ea964
NC		 3624 case EM_AARCH64:
3625 result = get_aarch64_segment_type (p_type);
3626 break;
b294bdf8
MM		 3627 case EM_ARM:
3628 result = get_arm_segment_type (p_type);
3629 break;
252b5132 3630 case EM_MIPS:
4fe85591 3631 case EM_MIPS_RS3_LE:
252b5132
RH		 3632 result = get_mips_segment_type (p_type);
3633 break;
103f02d3
UD		 3634 case EM_PARISC:
3635 result = get_parisc_segment_type (p_type);
3636 break;
4d6ed7c8
NC		 3637 case EM_IA_64:
3638 result = get_ia64_segment_type (p_type);
3639 break;
40b36596
JM		 3640 case EM_TI_C6000:
3641 result = get_tic6x_segment_type (p_type);
3642 break;
252b5132
RH		 3643 default:
3644 result = NULL;
3645 break;
3646 }
103f02d3 3647
252b5132
RH		 3648 if (result != NULL)
3649 return result;
103f02d3 3650
252b5132
RH		 3651 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3652 }
3653 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3654 {
2cf0635d 3655 const char * result;
103f02d3
UD		 3656
3657 switch (elf_header.e_machine)
3658 {
3659 case EM_PARISC:
3660 result = get_parisc_segment_type (p_type);
3661 break;
00428cca
AM		 3662 case EM_IA_64:
3663 result = get_ia64_segment_type (p_type);
3664 break;
103f02d3
UD		 3665 default:
3666 result = NULL;
3667 break;
3668 }
3669
3670 if (result != NULL)
3671 return result;
3672
3673 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3674 }
252b5132 3675 else
e9e44622 3676 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3677
3678 return buff;
3679 }
3680}
3681
3682static const char *
d3ba0551 3683get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3684{
3685 switch (sh_type)
3686 {
b34976b6
AM		 3687 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3688 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3689 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3690 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3691 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3692 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3693 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3694 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3695 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3696 case SHT_MIPS_RELD: return "MIPS_RELD";
3697 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3698 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3699 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3700 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3701 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3702 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3703 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3704 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3705 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3706 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3707 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3708 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3709 case SHT_MIPS_LINE: return "MIPS_LINE";
3710 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3711 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3712 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3713 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3714 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3715 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3716 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3717 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3718 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3719 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3720 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3721 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3722 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3723 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3724 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3725 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3726 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3727 default:
3728 break;
3729 }
3730 return NULL;
3731}
3732
103f02d3 3733static const char *
d3ba0551 3734get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3735{
3736 switch (sh_type)
3737 {
3738 case SHT_PARISC_EXT: return "PARISC_EXT";
3739 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3740 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3741 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3742 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3743 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3744 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3745 default:
3746 break;
3747 }
3748 return NULL;
3749}
3750
4d6ed7c8 3751static const char *
d3ba0551 3752get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3753{
18bd398b 3754 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3755 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3756 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3757
4d6ed7c8
NC		 3758 switch (sh_type)
3759 {
148b93f2
NC		 3760 case SHT_IA_64_EXT: return "IA_64_EXT";
3761 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3762 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3763 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3764 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3765 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3766 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3767 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3768 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3769 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3770 default:
3771 break;
3772 }
3773 return NULL;
3774}
3775
d2b2c203
DJ		 3776static const char *
3777get_x86_64_section_type_name (unsigned int sh_type)
3778{
3779 switch (sh_type)
3780 {
3781 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3782 default:
3783 break;
3784 }
3785 return NULL;
3786}
3787
a06ea964
NC		 3788static const char *
3789get_aarch64_section_type_name (unsigned int sh_type)
3790{
3791 switch (sh_type)
3792 {
3793 case SHT_AARCH64_ATTRIBUTES:
3794 return "AARCH64_ATTRIBUTES";
3795 default:
3796 break;
3797 }
3798 return NULL;
3799}
3800
40a18ebd
NC		 3801static const char *
3802get_arm_section_type_name (unsigned int sh_type)
3803{
3804 switch (sh_type)
3805 {
7f6fed87
NC		 3806 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3807 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3808 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3809 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3810 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3811 default:
3812 break;
3813 }
3814 return NULL;
3815}
3816
40b36596
JM		 3817static const char *
3818get_tic6x_section_type_name (unsigned int sh_type)
3819{
3820 switch (sh_type)
3821 {
3822 case SHT_C6000_UNWIND:
3823 return "C6000_UNWIND";
3824 case SHT_C6000_PREEMPTMAP:
3825 return "C6000_PREEMPTMAP";
3826 case SHT_C6000_ATTRIBUTES:
3827 return "C6000_ATTRIBUTES";
3828 case SHT_TI_ICODE:
3829 return "TI_ICODE";
3830 case SHT_TI_XREF:
3831 return "TI_XREF";
3832 case SHT_TI_HANDLER:
3833 return "TI_HANDLER";
3834 case SHT_TI_INITINFO:
3835 return "TI_INITINFO";
3836 case SHT_TI_PHATTRS:
3837 return "TI_PHATTRS";
3838 default:
3839 break;
3840 }
3841 return NULL;
3842}
3843
13761a11
NC		 3844static const char *
3845get_msp430x_section_type_name (unsigned int sh_type)
3846{
3847 switch (sh_type)
3848 {
3849 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3850 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3851 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3852 default: return NULL;
3853 }
3854}
3855
685080f2
NC		 3856static const char *
3857get_v850_section_type_name (unsigned int sh_type)
3858{
3859 switch (sh_type)
3860 {
3861 case SHT_V850_SCOMMON: return "V850 Small Common";
3862 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3863 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3864 case SHT_RENESAS_IOP: return "RENESAS IOP";
3865 case SHT_RENESAS_INFO: return "RENESAS INFO";
3866 default: return NULL;
3867 }
3868}
3869
252b5132 3870static const char *
d3ba0551 3871get_section_type_name (unsigned int sh_type)
252b5132 3872{
b34976b6 3873 static char buff[32];
252b5132
RH		 3874
3875 switch (sh_type)
3876 {
3877 case SHT_NULL: return "NULL";
3878 case SHT_PROGBITS: return "PROGBITS";
3879 case SHT_SYMTAB: return "SYMTAB";
3880 case SHT_STRTAB: return "STRTAB";
3881 case SHT_RELA: return "RELA";
3882 case SHT_HASH: return "HASH";
3883 case SHT_DYNAMIC: return "DYNAMIC";
3884 case SHT_NOTE: return "NOTE";
3885 case SHT_NOBITS: return "NOBITS";
3886 case SHT_REL: return "REL";
3887 case SHT_SHLIB: return "SHLIB";
3888 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3889 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3890 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3891 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3892 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3893 case SHT_GROUP: return "GROUP";
3894 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3895 case SHT_GNU_verdef: return "VERDEF";
3896 case SHT_GNU_verneed: return "VERNEED";
3897 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3898 case 0x6ffffff0: return "VERSYM";
3899 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3900 case 0x7ffffffd: return "AUXILIARY";
3901 case 0x7fffffff: return "FILTER";
047b2264 3902 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3903
3904 default:
3905 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3906 {
2cf0635d 3907 const char * result;
252b5132
RH		 3908
3909 switch (elf_header.e_machine)
3910 {
3911 case EM_MIPS:
4fe85591 3912 case EM_MIPS_RS3_LE:
252b5132
RH		 3913 result = get_mips_section_type_name (sh_type);
3914 break;
103f02d3
UD		 3915 case EM_PARISC:
3916 result = get_parisc_section_type_name (sh_type);
3917 break;
4d6ed7c8
NC		 3918 case EM_IA_64:
3919 result = get_ia64_section_type_name (sh_type);
3920 break;
d2b2c203 3921 case EM_X86_64:
8a9036a4 3922 case EM_L1OM:
7a9068fe 3923 case EM_K1OM:
d2b2c203
DJ		 3924 result = get_x86_64_section_type_name (sh_type);
3925 break;
a06ea964
NC		 3926 case EM_AARCH64:
3927 result = get_aarch64_section_type_name (sh_type);
3928 break;
40a18ebd
NC		 3929 case EM_ARM:
3930 result = get_arm_section_type_name (sh_type);
3931 break;
40b36596
JM		 3932 case EM_TI_C6000:
3933 result = get_tic6x_section_type_name (sh_type);
3934 break;
13761a11
NC		 3935 case EM_MSP430:
3936 result = get_msp430x_section_type_name (sh_type);
3937 break;
685080f2
NC		 3938 case EM_V800:
3939 case EM_V850:
3940 case EM_CYGNUS_V850:
3941 result = get_v850_section_type_name (sh_type);
3942 break;
252b5132
RH		 3943 default:
3944 result = NULL;
3945 break;
3946 }
3947
3948 if (result != NULL)
3949 return result;
3950
c91d0dfb 3951 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3952 }
3953 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3954 {
2cf0635d 3955 const char * result;
148b93f2
NC		 3956
3957 switch (elf_header.e_machine)
3958 {
3959 case EM_IA_64:
3960 result = get_ia64_section_type_name (sh_type);
3961 break;
3962 default:
3963 result = NULL;
3964 break;
3965 }
3966
3967 if (result != NULL)
3968 return result;
3969
3970 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3971 }
252b5132 3972 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3973 {
3974 switch (elf_header.e_machine)
3975 {
3976 case EM_V800:
3977 case EM_V850:
3978 case EM_CYGNUS_V850:
3979 return get_v850_section_type_name (sh_type);
3980 default:
3981 break;
3982 }
3983
3984 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3985 }
252b5132 3986 else
a7dbfd1c
NC		 3987 /* This message is probably going to be displayed in a 15
3988 character wide field, so put the hex value first. */
3989 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3990
252b5132
RH		 3991 return buff;
3992 }
3993}
3994
2979dc34 3995#define OPTION_DEBUG_DUMP 512
2c610e4b 3996#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3997#define OPTION_DWARF_DEPTH 514
3998#define OPTION_DWARF_START 515
4723351a 3999#define OPTION_DWARF_CHECK 516
2979dc34 4000
85b1c36d 4001static struct option options[] =
252b5132 4002{
b34976b6 4003 {"all", no_argument, 0, 'a'},
252b5132
RH		 4004 {"file-header", no_argument, 0, 'h'},
4005 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4006 {"headers", no_argument, 0, 'e'},
4007 {"histogram", no_argument, 0, 'I'},
4008 {"segments", no_argument, 0, 'l'},
4009 {"sections", no_argument, 0, 'S'},
252b5132 4010 {"section-headers", no_argument, 0, 'S'},
f5842774 4011 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4012 {"section-details", no_argument, 0, 't'},
595cf52e 4013 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4014 {"symbols", no_argument, 0, 's'},
4015 {"syms", no_argument, 0, 's'},
2c610e4b 4016 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4017 {"relocs", no_argument, 0, 'r'},
4018 {"notes", no_argument, 0, 'n'},
4019 {"dynamic", no_argument, 0, 'd'},
a952a375 4020 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4021 {"version-info", no_argument, 0, 'V'},
4022 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4023 {"unwind", no_argument, 0, 'u'},
4145f1d5 4024 {"archive-index", no_argument, 0, 'c'},
b34976b6 4025 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4026 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4027 {"string-dump", required_argument, 0, 'p'},
0e602686 4028 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4029#ifdef SUPPORT_DISASSEMBLY
4030 {"instruction-dump", required_argument, 0, 'i'},
4031#endif
cf13d699 4032 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4033
fd2f0033
TT		 4034 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4035 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4036 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4037
b34976b6
AM		 4038 {"version", no_argument, 0, 'v'},
4039 {"wide", no_argument, 0, 'W'},
4040 {"help", no_argument, 0, 'H'},
4041 {0, no_argument, 0, 0}
252b5132
RH		 4042};
4043
4044static void
2cf0635d 4045usage (FILE * stream)
252b5132 4046{
92f01d61
JM		 4047 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4048 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4049 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4050 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4051 -h --file-header Display the ELF file header\n\
4052 -l --program-headers Display the program headers\n\
4053 --segments An alias for --program-headers\n\
4054 -S --section-headers Display the sections' header\n\
4055 --sections An alias for --section-headers\n\
f5842774 4056 -g --section-groups Display the section groups\n\
5477e8a0 4057 -t --section-details Display the section details\n\
8b53311e
NC		 4058 -e --headers Equivalent to: -h -l -S\n\
4059 -s --syms Display the symbol table\n\
3f08eb35 4060 --symbols An alias for --syms\n\
2c610e4b 4061 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4062 -n --notes Display the core notes (if present)\n\
4063 -r --relocs Display the relocations (if present)\n\
4064 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4065 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4066 -V --version-info Display the version sections (if present)\n\
1b31d05e 4067 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4068 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4069 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4070 -x --hex-dump=<number|name>\n\
4071 Dump the contents of section <number|name> as bytes\n\
4072 -p --string-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4074 -R --relocated-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4076 -z --decompress Decompress section before dumping it\n\
f9f0e732 4077 -w[lLiaprmfFsoRt] or\n\
1ed06042 4078 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4079 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4080 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4081 =addr,=cu_index]\n\
8b53311e 4082 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4083 fprintf (stream, _("\
4084 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4085 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4086 or deeper\n"));
252b5132 4087#ifdef SUPPORT_DISASSEMBLY
92f01d61 4088 fprintf (stream, _("\
09c11c86
NC		 4089 -i --instruction-dump=<number|name>\n\
4090 Disassemble the contents of section <number|name>\n"));
252b5132 4091#endif
92f01d61 4092 fprintf (stream, _("\
8b53311e
NC		 4093 -I --histogram Display histogram of bucket list lengths\n\
4094 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4095 @<file> Read options from <file>\n\
8b53311e
NC		 4096 -H --help Display this information\n\
4097 -v --version Display the version number of readelf\n"));
1118d252 4098
92f01d61
JM		 4099 if (REPORT_BUGS_TO[0] && stream == stdout)
4100 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4101
92f01d61 4102 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4103}
4104
18bd398b
NC		 4105/* Record the fact that the user wants the contents of section number
4106 SECTION to be displayed using the method(s) encoded as flags bits
4107 in TYPE. Note, TYPE can be zero if we are creating the array for
4108 the first time. */
4109
252b5132 4110static void
09c11c86 4111request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4112{
4113 if (section >= num_dump_sects)
4114 {
2cf0635d 4115 dump_type * new_dump_sects;
252b5132 4116
3f5e193b
NC		 4117 new_dump_sects = (dump_type *) calloc (section + 1,
4118 sizeof (* dump_sects));
252b5132
RH		 4119
4120 if (new_dump_sects == NULL)
591a748a 4121 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4122 else
4123 {
4124 /* Copy current flag settings. */
09c11c86 4125 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4126
4127 free (dump_sects);
4128
4129 dump_sects = new_dump_sects;
4130 num_dump_sects = section + 1;
4131 }
4132 }
4133
4134 if (dump_sects)
b34976b6 4135 dump_sects[section] |= type;
252b5132
RH		 4136
4137 return;
4138}
4139
aef1f6d0
DJ		 4140/* Request a dump by section name. */
4141
4142static void
2cf0635d 4143request_dump_byname (const char * section, dump_type type)
aef1f6d0 4144{
2cf0635d 4145 struct dump_list_entry * new_request;
aef1f6d0 4146
3f5e193b
NC		 4147 new_request = (struct dump_list_entry *)
4148 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4149 if (!new_request)
591a748a 4150 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4151
4152 new_request->name = strdup (section);
4153 if (!new_request->name)
591a748a 4154 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4155
4156 new_request->type = type;
4157
4158 new_request->next = dump_sects_byname;
4159 dump_sects_byname = new_request;
4160}
4161
cf13d699
NC		 4162static inline void
4163request_dump (dump_type type)
4164{
4165 int section;
4166 char * cp;
4167
4168 do_dump++;
4169 section = strtoul (optarg, & cp, 0);
4170
4171 if (! *cp && section >= 0)
4172 request_dump_bynumber (section, type);
4173 else
4174 request_dump_byname (optarg, type);
4175}
4176
4177
252b5132 4178static void
2cf0635d 4179parse_args (int argc, char ** argv)
252b5132
RH		 4180{
4181 int c;
4182
4183 if (argc < 2)
92f01d61 4184 usage (stderr);
252b5132
RH		 4185
4186 while ((c = getopt_long
0e602686 4187 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4188 {
252b5132
RH		 4189 switch (c)
4190 {
4191 case 0:
4192 /* Long options. */
4193 break;
4194 case 'H':
92f01d61 4195 usage (stdout);
252b5132
RH		 4196 break;
4197
4198 case 'a':
b34976b6
AM		 4199 do_syms++;
4200 do_reloc++;
4201 do_unwind++;
4202 do_dynamic++;
4203 do_header++;
4204 do_sections++;
f5842774 4205 do_section_groups++;
b34976b6
AM		 4206 do_segments++;
4207 do_version++;
4208 do_histogram++;
4209 do_arch++;
4210 do_notes++;
252b5132 4211 break;
f5842774
L		 4212 case 'g':
4213 do_section_groups++;
4214 break;
5477e8a0 4215 case 't':
595cf52e 4216 case 'N':
5477e8a0
L		 4217 do_sections++;
4218 do_section_details++;
595cf52e 4219 break;
252b5132 4220 case 'e':
b34976b6
AM		 4221 do_header++;
4222 do_sections++;
4223 do_segments++;
252b5132 4224 break;
a952a375 4225 case 'A':
b34976b6 4226 do_arch++;
a952a375 4227 break;
252b5132 4228 case 'D':
b34976b6 4229 do_using_dynamic++;
252b5132
RH		 4230 break;
4231 case 'r':
b34976b6 4232 do_reloc++;
252b5132 4233 break;
4d6ed7c8 4234 case 'u':
b34976b6 4235 do_unwind++;
4d6ed7c8 4236 break;
252b5132 4237 case 'h':
b34976b6 4238 do_header++;
252b5132
RH		 4239 break;
4240 case 'l':
b34976b6 4241 do_segments++;
252b5132
RH		 4242 break;
4243 case 's':
b34976b6 4244 do_syms++;
252b5132
RH		 4245 break;
4246 case 'S':
b34976b6 4247 do_sections++;
252b5132
RH		 4248 break;
4249 case 'd':
b34976b6 4250 do_dynamic++;
252b5132 4251 break;
a952a375 4252 case 'I':
b34976b6 4253 do_histogram++;
a952a375 4254 break;
779fe533 4255 case 'n':
b34976b6 4256 do_notes++;
779fe533 4257 break;
4145f1d5
NC		 4258 case 'c':
4259 do_archive_index++;
4260 break;
252b5132 4261 case 'x':
cf13d699 4262 request_dump (HEX_DUMP);
aef1f6d0 4263 break;
09c11c86 4264 case 'p':
cf13d699
NC		 4265 request_dump (STRING_DUMP);
4266 break;
4267 case 'R':
4268 request_dump (RELOC_DUMP);
09c11c86 4269 break;
0e602686
NC		 4270 case 'z':
4271 decompress_dumps++;
4272 break;
252b5132 4273 case 'w':
b34976b6 4274 do_dump++;
252b5132 4275 if (optarg == 0)
613ff48b
CC		 4276 {
4277 do_debugging = 1;
4278 dwarf_select_sections_all ();
4279 }
252b5132
RH		 4280 else
4281 {
4282 do_debugging = 0;
4cb93e3b 4283 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4284 }
4285 break;
2979dc34 4286 case OPTION_DEBUG_DUMP:
b34976b6 4287 do_dump++;
2979dc34
JJ		 4288 if (optarg == 0)
4289 do_debugging = 1;
4290 else
4291 {
2979dc34 4292 do_debugging = 0;
4cb93e3b 4293 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4294 }
4295 break;
fd2f0033
TT		 4296 case OPTION_DWARF_DEPTH:
4297 {
4298 char *cp;
4299
4300 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4301 }
4302 break;
4303 case OPTION_DWARF_START:
4304 {
4305 char *cp;
4306
4307 dwarf_start_die = strtoul (optarg, & cp, 0);
4308 }
4309 break;
4723351a
CC		 4310 case OPTION_DWARF_CHECK:
4311 dwarf_check = 1;
4312 break;
2c610e4b
L		 4313 case OPTION_DYN_SYMS:
4314 do_dyn_syms++;
4315 break;
252b5132
RH		 4316#ifdef SUPPORT_DISASSEMBLY
4317 case 'i':
cf13d699
NC		 4318 request_dump (DISASS_DUMP);
4319 break;
252b5132
RH		 4320#endif
4321 case 'v':
4322 print_version (program_name);
4323 break;
4324 case 'V':
b34976b6 4325 do_version++;
252b5132 4326 break;
d974e256 4327 case 'W':
b34976b6 4328 do_wide++;
d974e256 4329 break;
252b5132 4330 default:
252b5132
RH		 4331 /* xgettext:c-format */
4332 error (_("Invalid option '-%c'\n"), c);
4333 /* Drop through. */
4334 case '?':
92f01d61 4335 usage (stderr);
252b5132
RH		 4336 }
4337 }
4338
4d6ed7c8 4339 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4340 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4341 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4342 && !do_section_groups && !do_archive_index
4343 && !do_dyn_syms)
92f01d61 4344 usage (stderr);
252b5132
RH		 4345}
4346
4347static const char *
d3ba0551 4348get_elf_class (unsigned int elf_class)
252b5132 4349{
b34976b6 4350 static char buff[32];
103f02d3 4351
252b5132
RH		 4352 switch (elf_class)
4353 {
4354 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4355 case ELFCLASS32: return "ELF32";
4356 case ELFCLASS64: return "ELF64";
ab5e7794 4357 default:
e9e44622 4358 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4359 return buff;
252b5132
RH		 4360 }
4361}
4362
4363static const char *
d3ba0551 4364get_data_encoding (unsigned int encoding)
252b5132 4365{
b34976b6 4366 static char buff[32];
103f02d3 4367
252b5132
RH		 4368 switch (encoding)
4369 {
4370 case ELFDATANONE: return _("none");
33c63f9d
CM		 4371 case ELFDATA2LSB: return _("2's complement, little endian");
4372 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4373 default:
e9e44622 4374 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4375 return buff;
252b5132
RH		 4376 }
4377}
4378
252b5132 4379/* Decode the data held in 'elf_header'. */
ee42cf8c 4380
252b5132 4381static int
d3ba0551 4382process_file_header (void)
252b5132 4383{
b34976b6
AM		 4384 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4385 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4386 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4387 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4388 {
4389 error
4390 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4391 return 0;
4392 }
4393
2dc4cec1
L		 4394 init_dwarf_regnames (elf_header.e_machine);
4395
252b5132
RH		 4396 if (do_header)
4397 {
4398 int i;
4399
4400 printf (_("ELF Header:\n"));
4401 printf (_(" Magic: "));
b34976b6
AM		 4402 for (i = 0; i < EI_NIDENT; i++)
4403 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4404 printf ("\n");
4405 printf (_(" Class: %s\n"),
b34976b6 4406 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4407 printf (_(" Data: %s\n"),
b34976b6 4408 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4409 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4410 elf_header.e_ident[EI_VERSION],
4411 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4412 ? "(current)"
b34976b6 4413 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4414 ? _("<unknown: %lx>")
789be9f7 4415 : "")));
252b5132 4416 printf (_(" OS/ABI: %s\n"),
b34976b6 4417 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4418 printf (_(" ABI Version: %d\n"),
b34976b6 4419 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4420 printf (_(" Type: %s\n"),
4421 get_file_type (elf_header.e_type));
4422 printf (_(" Machine: %s\n"),
4423 get_machine_name (elf_header.e_machine));
4424 printf (_(" Version: 0x%lx\n"),
4425 (unsigned long) elf_header.e_version);
76da6bbe 4426
f7a99963
NC		 4427 printf (_(" Entry point address: "));
4428 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4429 printf (_("\n Start of program headers: "));
4430 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4431 printf (_(" (bytes into file)\n Start of section headers: "));
4432 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4433 printf (_(" (bytes into file)\n"));
76da6bbe 4434
252b5132
RH		 4435 printf (_(" Flags: 0x%lx%s\n"),
4436 (unsigned long) elf_header.e_flags,
4437 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4438 printf (_(" Size of this header: %ld (bytes)\n"),
4439 (long) elf_header.e_ehsize);
4440 printf (_(" Size of program headers: %ld (bytes)\n"),
4441 (long) elf_header.e_phentsize);
2046a35d 4442 printf (_(" Number of program headers: %ld"),
252b5132 4443 (long) elf_header.e_phnum);
2046a35d
AM		 4444 if (section_headers != NULL
4445 && elf_header.e_phnum == PN_XNUM
4446 && section_headers[0].sh_info != 0)
cc5914eb 4447 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4448 putc ('\n', stdout);
252b5132
RH		 4449 printf (_(" Size of section headers: %ld (bytes)\n"),
4450 (long) elf_header.e_shentsize);
560f3c1c 4451 printf (_(" Number of section headers: %ld"),
252b5132 4452 (long) elf_header.e_shnum);
4fbb74a6 4453 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4454 printf (" (%ld)", (long) section_headers[0].sh_size);
4455 putc ('\n', stdout);
4456 printf (_(" Section header string table index: %ld"),
252b5132 4457 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4458 if (section_headers != NULL
4459 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4460 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4461 else if (elf_header.e_shstrndx != SHN_UNDEF
4462 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4463 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4464 putc ('\n', stdout);
4465 }
4466
4467 if (section_headers != NULL)
4468 {
2046a35d
AM		 4469 if (elf_header.e_phnum == PN_XNUM
4470 && section_headers[0].sh_info != 0)
4471 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4472 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4473 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4474 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4475 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4476 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4477 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4478 free (section_headers);
4479 section_headers = NULL;
252b5132 4480 }
103f02d3 4481
9ea033b2
NC		 4482 return 1;
4483}
4484
e0a31db1 4485static bfd_boolean
91d6fa6a 4486get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4487{
2cf0635d
NC		 4488 Elf32_External_Phdr * phdrs;
4489 Elf32_External_Phdr * external;
4490 Elf_Internal_Phdr * internal;
b34976b6 4491 unsigned int i;
e0a31db1
NC		 4492 unsigned int size = elf_header.e_phentsize;
4493 unsigned int num = elf_header.e_phnum;
4494
4495 /* PR binutils/17531: Cope with unexpected section header sizes. */
4496 if (size == 0 || num == 0)
4497 return FALSE;
4498 if (size < sizeof * phdrs)
4499 {
4500 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4501 return FALSE;
4502 }
4503 if (size > sizeof * phdrs)
4504 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4505
3f5e193b 4506 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4507 size, num, _("program headers"));
4508 if (phdrs == NULL)
4509 return FALSE;
9ea033b2 4510
91d6fa6a 4511 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4512 i < elf_header.e_phnum;
b34976b6 4513 i++, internal++, external++)
252b5132 4514 {
9ea033b2
NC		 4515 internal->p_type = BYTE_GET (external->p_type);
4516 internal->p_offset = BYTE_GET (external->p_offset);
4517 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4518 internal->p_paddr = BYTE_GET (external->p_paddr);
4519 internal->p_filesz = BYTE_GET (external->p_filesz);
4520 internal->p_memsz = BYTE_GET (external->p_memsz);
4521 internal->p_flags = BYTE_GET (external->p_flags);
4522 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4523 }
4524
9ea033b2 4525 free (phdrs);
e0a31db1 4526 return TRUE;
252b5132
RH		 4527}
4528
e0a31db1 4529static bfd_boolean
91d6fa6a 4530get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4531{
2cf0635d
NC		 4532 Elf64_External_Phdr * phdrs;
4533 Elf64_External_Phdr * external;
4534 Elf_Internal_Phdr * internal;
b34976b6 4535 unsigned int i;
e0a31db1
NC		 4536 unsigned int size = elf_header.e_phentsize;
4537 unsigned int num = elf_header.e_phnum;
4538
4539 /* PR binutils/17531: Cope with unexpected section header sizes. */
4540 if (size == 0 || num == 0)
4541 return FALSE;
4542 if (size < sizeof * phdrs)
4543 {
4544 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4545 return FALSE;
4546 }
4547 if (size > sizeof * phdrs)
4548 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4549
3f5e193b 4550 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4551 size, num, _("program headers"));
a6e9f9df 4552 if (!phdrs)
e0a31db1 4553 return FALSE;
9ea033b2 4554
91d6fa6a 4555 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4556 i < elf_header.e_phnum;
b34976b6 4557 i++, internal++, external++)
9ea033b2
NC		 4558 {
4559 internal->p_type = BYTE_GET (external->p_type);
4560 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4561 internal->p_offset = BYTE_GET (external->p_offset);
4562 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4563 internal->p_paddr = BYTE_GET (external->p_paddr);
4564 internal->p_filesz = BYTE_GET (external->p_filesz);
4565 internal->p_memsz = BYTE_GET (external->p_memsz);
4566 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4567 }
4568
4569 free (phdrs);
e0a31db1 4570 return TRUE;
9ea033b2 4571}
252b5132 4572
d93f0186
NC		 4573/* Returns 1 if the program headers were read into `program_headers'. */
4574
4575static int
2cf0635d 4576get_program_headers (FILE * file)
d93f0186 4577{
2cf0635d 4578 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4579
4580 /* Check cache of prior read. */
4581 if (program_headers != NULL)
4582 return 1;
4583
3f5e193b
NC		 4584 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4585 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4586
4587 if (phdrs == NULL)
4588 {
8b73c356
NC		 4589 error (_("Out of memory reading %u program headers\n"),
4590 elf_header.e_phnum);
d93f0186
NC		 4591 return 0;
4592 }
4593
4594 if (is_32bit_elf
4595 ? get_32bit_program_headers (file, phdrs)
4596 : get_64bit_program_headers (file, phdrs))
4597 {
4598 program_headers = phdrs;
4599 return 1;
4600 }
4601
4602 free (phdrs);
4603 return 0;
4604}
4605
2f62977e
NC		 4606/* Returns 1 if the program headers were loaded. */
4607
252b5132 4608static int
2cf0635d 4609process_program_headers (FILE * file)
252b5132 4610{
2cf0635d 4611 Elf_Internal_Phdr * segment;
b34976b6 4612 unsigned int i;
252b5132
RH		 4613
4614 if (elf_header.e_phnum == 0)
4615 {
82f2dbf7
NC		 4616 /* PR binutils/12467. */
4617 if (elf_header.e_phoff != 0)
4618 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4619 " header offset, but no program headers\n"));
82f2dbf7 4620 else if (do_segments)
252b5132 4621 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4622 return 0;
252b5132
RH		 4623 }
4624
4625 if (do_segments && !do_header)
4626 {
f7a99963
NC		 4627 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4628 printf (_("Entry point "));
4629 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4630 printf (_("\nThere are %d program headers, starting at offset "),
4631 elf_header.e_phnum);
4632 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4633 printf ("\n");
252b5132
RH		 4634 }
4635
d93f0186 4636 if (! get_program_headers (file))
252b5132 4637 return 0;
103f02d3 4638
252b5132
RH		 4639 if (do_segments)
4640 {
3a1a2036
NC		 4641 if (elf_header.e_phnum > 1)
4642 printf (_("\nProgram Headers:\n"));
4643 else
4644 printf (_("\nProgram Headers:\n"));
76da6bbe 4645
f7a99963
NC		 4646 if (is_32bit_elf)
4647 printf
4648 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4649 else if (do_wide)
4650 printf
4651 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4652 else
4653 {
4654 printf
4655 (_(" Type Offset VirtAddr PhysAddr\n"));
4656 printf
4657 (_(" FileSiz MemSiz Flags Align\n"));
4658 }
252b5132
RH		 4659 }
4660
252b5132 4661 dynamic_addr = 0;
1b228002 4662 dynamic_size = 0;
252b5132
RH		 4663
4664 for (i = 0, segment = program_headers;
4665 i < elf_header.e_phnum;
b34976b6 4666 i++, segment++)
252b5132
RH		 4667 {
4668 if (do_segments)
4669 {
103f02d3 4670 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4671
4672 if (is_32bit_elf)
4673 {
4674 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4675 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4676 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4677 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4678 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4679 printf ("%c%c%c ",
4680 (segment->p_flags & PF_R ? 'R' : ' '),
4681 (segment->p_flags & PF_W ? 'W' : ' '),
4682 (segment->p_flags & PF_X ? 'E' : ' '));
4683 printf ("%#lx", (unsigned long) segment->p_align);
4684 }
d974e256
JJ		 4685 else if (do_wide)
4686 {
4687 if ((unsigned long) segment->p_offset == segment->p_offset)
4688 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4689 else
4690 {
4691 print_vma (segment->p_offset, FULL_HEX);
4692 putchar (' ');
4693 }
4694
4695 print_vma (segment->p_vaddr, FULL_HEX);
4696 putchar (' ');
4697 print_vma (segment->p_paddr, FULL_HEX);
4698 putchar (' ');
4699
4700 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4701 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4702 else
4703 {
4704 print_vma (segment->p_filesz, FULL_HEX);
4705 putchar (' ');
4706 }
4707
4708 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4709 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4710 else
4711 {
f48e6c45 4712 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4713 }
4714
4715 printf (" %c%c%c ",
4716 (segment->p_flags & PF_R ? 'R' : ' '),
4717 (segment->p_flags & PF_W ? 'W' : ' '),
4718 (segment->p_flags & PF_X ? 'E' : ' '));
4719
4720 if ((unsigned long) segment->p_align == segment->p_align)
4721 printf ("%#lx", (unsigned long) segment->p_align);
4722 else
4723 {
4724 print_vma (segment->p_align, PREFIX_HEX);
4725 }
4726 }
f7a99963
NC		 4727 else
4728 {
4729 print_vma (segment->p_offset, FULL_HEX);
4730 putchar (' ');
4731 print_vma (segment->p_vaddr, FULL_HEX);
4732 putchar (' ');
4733 print_vma (segment->p_paddr, FULL_HEX);
4734 printf ("\n ");
4735 print_vma (segment->p_filesz, FULL_HEX);
4736 putchar (' ');
4737 print_vma (segment->p_memsz, FULL_HEX);
4738 printf (" %c%c%c ",
4739 (segment->p_flags & PF_R ? 'R' : ' '),
4740 (segment->p_flags & PF_W ? 'W' : ' '),
4741 (segment->p_flags & PF_X ? 'E' : ' '));
4742 print_vma (segment->p_align, HEX);
4743 }
252b5132
RH		 4744 }
4745
f54498b4
NC		 4746 if (do_segments)
4747 putc ('\n', stdout);
4748
252b5132
RH		 4749 switch (segment->p_type)
4750 {
252b5132
RH		 4751 case PT_DYNAMIC:
4752 if (dynamic_addr)
4753 error (_("more than one dynamic segment\n"));
4754
20737c13
AM		 4755 /* By default, assume that the .dynamic section is the first
4756 section in the DYNAMIC segment. */
4757 dynamic_addr = segment->p_offset;
4758 dynamic_size = segment->p_filesz;
f54498b4
NC		 4759 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4760 if (dynamic_addr + dynamic_size >= current_file_size)
4761 {
4762 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4763 dynamic_addr = dynamic_size = 0;
4764 }
20737c13 4765
b2d38a17
NC		 4766 /* Try to locate the .dynamic section. If there is
4767 a section header table, we can easily locate it. */
4768 if (section_headers != NULL)
4769 {
2cf0635d 4770 Elf_Internal_Shdr * sec;
b2d38a17 4771
89fac5e3
RS		 4772 sec = find_section (".dynamic");
4773 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4774 {
28f997cf
TG		 4775 /* A corresponding .dynamic section is expected, but on
4776 IA-64/OpenVMS it is OK for it to be missing. */
4777 if (!is_ia64_vms ())
4778 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4779 break;
4780 }
4781
42bb2e33 4782 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4783 {
4784 dynamic_size = 0;
4785 break;
4786 }
42bb2e33 4787
b2d38a17
NC		 4788 dynamic_addr = sec->sh_offset;
4789 dynamic_size = sec->sh_size;
4790
4791 if (dynamic_addr < segment->p_offset
4792 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4793 warn (_("the .dynamic section is not contained"
4794 " within the dynamic segment\n"));
b2d38a17 4795 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4796 warn (_("the .dynamic section is not the first section"
4797 " in the dynamic segment.\n"));
b2d38a17 4798 }
252b5132
RH		 4799 break;
4800
4801 case PT_INTERP:
fb52b2f4
NC		 4802 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4803 SEEK_SET))
252b5132
RH		 4804 error (_("Unable to find program interpreter name\n"));
4805 else
4806 {
f8eae8b2 4807 char fmt [32];
9495b2e6 4808 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4809
4810 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4811 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4812
252b5132 4813 program_interpreter[0] = 0;
7bd7b3ef
AM		 4814 if (fscanf (file, fmt, program_interpreter) <= 0)
4815 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4816
4817 if (do_segments)
f54498b4 4818 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4819 program_interpreter);
4820 }
4821 break;
4822 }
252b5132
RH		 4823 }
4824
c256ffe7 4825 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4826 {
4827 printf (_("\n Section to Segment mapping:\n"));
4828 printf (_(" Segment Sections...\n"));
4829
252b5132
RH		 4830 for (i = 0; i < elf_header.e_phnum; i++)
4831 {
9ad5cbcf 4832 unsigned int j;
2cf0635d 4833 Elf_Internal_Shdr * section;
252b5132
RH		 4834
4835 segment = program_headers + i;
b391a3e3 4836 section = section_headers + 1;
252b5132
RH		 4837
4838 printf (" %2.2d ", i);
4839
b34976b6 4840 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4841 {
f4638467
AM		 4842 if (!ELF_TBSS_SPECIAL (section, segment)
4843 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4844 printf ("%s ", printable_section_name (section));
252b5132
RH		 4845 }
4846
4847 putc ('\n',stdout);
4848 }
4849 }
4850
252b5132
RH		 4851 return 1;
4852}
4853
4854
d93f0186
NC		 4855/* Find the file offset corresponding to VMA by using the program headers. */
4856
4857static long
2cf0635d 4858offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4859{
2cf0635d 4860 Elf_Internal_Phdr * seg;
d93f0186
NC		 4861
4862 if (! get_program_headers (file))
4863 {
4864 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4865 return (long) vma;
4866 }
4867
4868 for (seg = program_headers;
4869 seg < program_headers + elf_header.e_phnum;
4870 ++seg)
4871 {
4872 if (seg->p_type != PT_LOAD)
4873 continue;
4874
4875 if (vma >= (seg->p_vaddr & -seg->p_align)
4876 && vma + size <= seg->p_vaddr + seg->p_filesz)
4877 return vma - seg->p_vaddr + seg->p_offset;
4878 }
4879
4880 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4881 (unsigned long) vma);
d93f0186
NC		 4882 return (long) vma;
4883}
4884
4885
049b0c3a
NC		 4886/* Allocate memory and load the sections headers into the global pointer
4887 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4888 generate any error messages if the load fails. */
4889
4890static bfd_boolean
4891get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4892{
2cf0635d
NC		 4893 Elf32_External_Shdr * shdrs;
4894 Elf_Internal_Shdr * internal;
b34976b6 4895 unsigned int i;
049b0c3a
NC		 4896 unsigned int size = elf_header.e_shentsize;
4897 unsigned int num = probe ? 1 : elf_header.e_shnum;
4898
4899 /* PR binutils/17531: Cope with unexpected section header sizes. */
4900 if (size == 0 || num == 0)
4901 return FALSE;
4902 if (size < sizeof * shdrs)
4903 {
4904 if (! probe)
4905 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4906 return FALSE;
4907 }
4908 if (!probe && size > sizeof * shdrs)
4909 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4910
3f5e193b 4911 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4912 size, num,
4913 probe ? NULL : _("section headers"));
4914 if (shdrs == NULL)
4915 return FALSE;
252b5132 4916
049b0c3a
NC		 4917 if (section_headers != NULL)
4918 free (section_headers);
3f5e193b
NC		 4919 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4920 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4921 if (section_headers == NULL)
4922 {
049b0c3a 4923 if (!probe)
8b73c356 4924 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4925 return FALSE;
252b5132
RH		 4926 }
4927
4928 for (i = 0, internal = section_headers;
560f3c1c 4929 i < num;
b34976b6 4930 i++, internal++)
252b5132
RH		 4931 {
4932 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4933 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4934 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4935 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4936 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4937 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4938 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4939 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4940 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4941 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4942 }
4943
4944 free (shdrs);
049b0c3a 4945 return TRUE;
252b5132
RH		 4946}
4947
049b0c3a
NC		 4948static bfd_boolean
4949get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4950{
2cf0635d
NC		 4951 Elf64_External_Shdr * shdrs;
4952 Elf_Internal_Shdr * internal;
b34976b6 4953 unsigned int i;
049b0c3a
NC		 4954 unsigned int size = elf_header.e_shentsize;
4955 unsigned int num = probe ? 1 : elf_header.e_shnum;
4956
4957 /* PR binutils/17531: Cope with unexpected section header sizes. */
4958 if (size == 0 || num == 0)
4959 return FALSE;
4960 if (size < sizeof * shdrs)
4961 {
4962 if (! probe)
4963 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4964 return FALSE;
4965 }
4966 if (! probe && size > sizeof * shdrs)
4967 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4968
3f5e193b 4969 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4970 size, num,
4971 probe ? NULL : _("section headers"));
4972 if (shdrs == NULL)
4973 return FALSE;
9ea033b2 4974
049b0c3a
NC		 4975 if (section_headers != NULL)
4976 free (section_headers);
3f5e193b
NC		 4977 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4978 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4979 if (section_headers == NULL)
4980 {
049b0c3a 4981 if (! probe)
8b73c356 4982 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4983 return FALSE;
9ea033b2
NC		 4984 }
4985
4986 for (i = 0, internal = section_headers;
560f3c1c 4987 i < num;
b34976b6 4988 i++, internal++)
9ea033b2
NC		 4989 {
4990 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4991 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4992 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4993 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4994 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4995 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4996 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4997 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4998 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4999 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5000 }
5001
5002 free (shdrs);
049b0c3a 5003 return TRUE;
9ea033b2
NC		 5004}
5005
252b5132 5006static Elf_Internal_Sym *
ba5cdace
NC		 5007get_32bit_elf_symbols (FILE * file,
5008 Elf_Internal_Shdr * section,
5009 unsigned long * num_syms_return)
252b5132 5010{
ba5cdace 5011 unsigned long number = 0;
dd24e3da 5012 Elf32_External_Sym * esyms = NULL;
ba5cdace 5013 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5014 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5015 Elf_Internal_Sym * psym;
b34976b6 5016 unsigned int j;
252b5132 5017
c9c1d674
EG		 5018 if (section->sh_size == 0)
5019 {
5020 if (num_syms_return != NULL)
5021 * num_syms_return = 0;
5022 return NULL;
5023 }
5024
dd24e3da 5025 /* Run some sanity checks first. */
c9c1d674 5026 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5027 {
c9c1d674
EG		 5028 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5029 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5030 goto exit_point;
dd24e3da
NC		 5031 }
5032
f54498b4
NC		 5033 if (section->sh_size > current_file_size)
5034 {
5035 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5036 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5037 goto exit_point;
5038 }
5039
dd24e3da
NC		 5040 number = section->sh_size / section->sh_entsize;
5041
5042 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5043 {
c9c1d674 5044 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5045 (unsigned long) section->sh_size,
5046 printable_section_name (section),
5047 (unsigned long) section->sh_entsize);
ba5cdace 5048 goto exit_point;
dd24e3da
NC		 5049 }
5050
3f5e193b
NC		 5051 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5052 section->sh_size, _("symbols"));
dd24e3da 5053 if (esyms == NULL)
ba5cdace 5054 goto exit_point;
252b5132 5055
6a40cf0c
NC		 5056 {
5057 elf_section_list * entry;
5058
5059 shndx = NULL;
5060 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5061 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5062 {
6a40cf0c
NC		 5063 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5064 entry->hdr->sh_offset,
5065 1, entry->hdr->sh_size,
5066 _("symbol table section indicies"));
5067 if (shndx == NULL)
5068 goto exit_point;
5069 /* PR17531: file: heap-buffer-overflow */
5070 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5071 {
5072 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5073 printable_section_name (entry->hdr),
5074 (unsigned long) entry->hdr->sh_size,
5075 (unsigned long) section->sh_size);
5076 goto exit_point;
5077 }
c9c1d674 5078 }
6a40cf0c 5079 }
9ad5cbcf 5080
3f5e193b 5081 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5082
5083 if (isyms == NULL)
5084 {
8b73c356
NC		 5085 error (_("Out of memory reading %lu symbols\n"),
5086 (unsigned long) number);
dd24e3da 5087 goto exit_point;
252b5132
RH		 5088 }
5089
dd24e3da 5090 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5091 {
5092 psym->st_name = BYTE_GET (esyms[j].st_name);
5093 psym->st_value = BYTE_GET (esyms[j].st_value);
5094 psym->st_size = BYTE_GET (esyms[j].st_size);
5095 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5096 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5097 psym->st_shndx
5098 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5099 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5100 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5101 psym->st_info = BYTE_GET (esyms[j].st_info);
5102 psym->st_other = BYTE_GET (esyms[j].st_other);
5103 }
5104
dd24e3da 5105 exit_point:
ba5cdace 5106 if (shndx != NULL)
9ad5cbcf 5107 free (shndx);
ba5cdace 5108 if (esyms != NULL)
dd24e3da 5109 free (esyms);
252b5132 5110
ba5cdace
NC		 5111 if (num_syms_return != NULL)
5112 * num_syms_return = isyms == NULL ? 0 : number;
5113
252b5132
RH		 5114 return isyms;
5115}
5116
9ea033b2 5117static Elf_Internal_Sym *
ba5cdace
NC		 5118get_64bit_elf_symbols (FILE * file,
5119 Elf_Internal_Shdr * section,
5120 unsigned long * num_syms_return)
9ea033b2 5121{
ba5cdace
NC		 5122 unsigned long number = 0;
5123 Elf64_External_Sym * esyms = NULL;
5124 Elf_External_Sym_Shndx * shndx = NULL;
5125 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5126 Elf_Internal_Sym * psym;
b34976b6 5127 unsigned int j;
9ea033b2 5128
c9c1d674
EG		 5129 if (section->sh_size == 0)
5130 {
5131 if (num_syms_return != NULL)
5132 * num_syms_return = 0;
5133 return NULL;
5134 }
5135
dd24e3da 5136 /* Run some sanity checks first. */
c9c1d674 5137 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5138 {
c9c1d674 5139 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5140 printable_section_name (section),
5141 (unsigned long) section->sh_entsize);
ba5cdace 5142 goto exit_point;
dd24e3da
NC		 5143 }
5144
f54498b4
NC		 5145 if (section->sh_size > current_file_size)
5146 {
5147 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5148 printable_section_name (section),
5149 (unsigned long) section->sh_size);
f54498b4
NC		 5150 goto exit_point;
5151 }
5152
dd24e3da
NC		 5153 number = section->sh_size / section->sh_entsize;
5154
5155 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5156 {
c9c1d674 5157 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5158 (unsigned long) section->sh_size,
5159 printable_section_name (section),
5160 (unsigned long) section->sh_entsize);
ba5cdace 5161 goto exit_point;
dd24e3da
NC		 5162 }
5163
3f5e193b
NC		 5164 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5165 section->sh_size, _("symbols"));
a6e9f9df 5166 if (!esyms)
ba5cdace 5167 goto exit_point;
9ea033b2 5168
6a40cf0c
NC		 5169 {
5170 elf_section_list * entry;
5171
5172 shndx = NULL;
5173 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5174 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5175 {
6a40cf0c
NC		 5176 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5177 entry->hdr->sh_offset,
5178 1, entry->hdr->sh_size,
5179 _("symbol table section indicies"));
5180 if (shndx == NULL)
5181 goto exit_point;
5182 /* PR17531: file: heap-buffer-overflow */
5183 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5184 {
5185 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5186 printable_section_name (entry->hdr),
5187 (unsigned long) entry->hdr->sh_size,
5188 (unsigned long) section->sh_size);
5189 goto exit_point;
5190 }
c9c1d674 5191 }
6a40cf0c 5192 }
9ad5cbcf 5193
3f5e193b 5194 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5195
5196 if (isyms == NULL)
5197 {
8b73c356
NC		 5198 error (_("Out of memory reading %lu symbols\n"),
5199 (unsigned long) number);
ba5cdace 5200 goto exit_point;
9ea033b2
NC		 5201 }
5202
ba5cdace 5203 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5204 {
5205 psym->st_name = BYTE_GET (esyms[j].st_name);
5206 psym->st_info = BYTE_GET (esyms[j].st_info);
5207 psym->st_other = BYTE_GET (esyms[j].st_other);
5208 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5209
4fbb74a6 5210 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5211 psym->st_shndx
5212 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5213 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5214 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5215
66543521
AM		 5216 psym->st_value = BYTE_GET (esyms[j].st_value);
5217 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5218 }
5219
ba5cdace
NC		 5220 exit_point:
5221 if (shndx != NULL)
9ad5cbcf 5222 free (shndx);
ba5cdace
NC		 5223 if (esyms != NULL)
5224 free (esyms);
5225
5226 if (num_syms_return != NULL)
5227 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5228
5229 return isyms;
5230}
5231
d1133906 5232static const char *
d3ba0551 5233get_elf_section_flags (bfd_vma sh_flags)
d1133906 5234{
5477e8a0 5235 static char buff[1024];
2cf0635d 5236 char * p = buff;
8d5ff12c 5237 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5238 int sindex;
5239 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5240 bfd_vma os_flags = 0;
5241 bfd_vma proc_flags = 0;
5242 bfd_vma unknown_flags = 0;
148b93f2 5243 static const struct
5477e8a0 5244 {
2cf0635d 5245 const char * str;
5477e8a0
L		 5246 int len;
5247 }
5248 flags [] =
5249 {
cfcac11d
NC		 5250 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5251 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5252 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5253 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5254 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5255 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5256 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5257 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5258 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5259 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5260 /* IA-64 specific. */
5261 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5262 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5263 /* IA-64 OpenVMS specific. */
5264 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5265 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5266 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5267 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5268 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5269 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5270 /* Generic. */
cfcac11d 5271 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5272 /* SPARC specific. */
77115a4a
L		 5273 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5274 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5275 };
5276
5277 if (do_section_details)
5278 {
8d5ff12c
L		 5279 sprintf (buff, "[%*.*lx]: ",
5280 field_size, field_size, (unsigned long) sh_flags);
5281 p += field_size + 4;
5477e8a0 5282 }
76da6bbe 5283
d1133906
NC		 5284 while (sh_flags)
5285 {
5286 bfd_vma flag;
5287
5288 flag = sh_flags & - sh_flags;
5289 sh_flags &= ~ flag;
76da6bbe 5290
5477e8a0 5291 if (do_section_details)
d1133906 5292 {
5477e8a0
L		 5293 switch (flag)
5294 {
91d6fa6a
NC		 5295 case SHF_WRITE: sindex = 0; break;
5296 case SHF_ALLOC: sindex = 1; break;
5297 case SHF_EXECINSTR: sindex = 2; break;
5298 case SHF_MERGE: sindex = 3; break;
5299 case SHF_STRINGS: sindex = 4; break;
5300 case SHF_INFO_LINK: sindex = 5; break;
5301 case SHF_LINK_ORDER: sindex = 6; break;
5302 case SHF_OS_NONCONFORMING: sindex = 7; break;
5303 case SHF_GROUP: sindex = 8; break;
5304 case SHF_TLS: sindex = 9; break;
18ae9cc1 5305 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5306 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5307
5477e8a0 5308 default:
91d6fa6a 5309 sindex = -1;
cfcac11d 5310 switch (elf_header.e_machine)
148b93f2 5311 {
cfcac11d 5312 case EM_IA_64:
148b93f2 5313 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5314 sindex = 10;
148b93f2 5315 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5316 sindex = 11;
148b93f2
NC		 5317#ifdef BFD64
5318 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5319 switch (flag)
5320 {
91d6fa6a
NC		 5321 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5322 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5323 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5324 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5325 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5326 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5327 default: break;
5328 }
5329#endif
cfcac11d
NC		 5330 break;
5331
caa83f8b 5332 case EM_386:
22abe556 5333 case EM_IAMCU:
caa83f8b 5334 case EM_X86_64:
7f502d6c 5335 case EM_L1OM:
7a9068fe 5336 case EM_K1OM:
cfcac11d
NC		 5337 case EM_OLD_SPARCV9:
5338 case EM_SPARC32PLUS:
5339 case EM_SPARCV9:
5340 case EM_SPARC:
18ae9cc1 5341 if (flag == SHF_ORDERED)
91d6fa6a 5342 sindex = 19;
cfcac11d
NC		 5343 break;
5344 default:
5345 break;
148b93f2 5346 }
5477e8a0
L		 5347 }
5348
91d6fa6a 5349 if (sindex != -1)
5477e8a0 5350 {
8d5ff12c
L		 5351 if (p != buff + field_size + 4)
5352 {
5353 if (size < (10 + 2))
bee0ee85
NC		 5354 {
5355 warn (_("Internal error: not enough buffer room for section flag info"));
5356 return _("<unknown>");
5357 }
8d5ff12c
L		 5358 size -= 2;
5359 *p++ = ',';
5360 *p++ = ' ';
5361 }
5362
91d6fa6a
NC		 5363 size -= flags [sindex].len;
5364 p = stpcpy (p, flags [sindex].str);
5477e8a0 5365 }
3b22753a 5366 else if (flag & SHF_MASKOS)
8d5ff12c 5367 os_flags |= flag;
d1133906 5368 else if (flag & SHF_MASKPROC)
8d5ff12c 5369 proc_flags |= flag;
d1133906 5370 else
8d5ff12c 5371 unknown_flags |= flag;
5477e8a0
L		 5372 }
5373 else
5374 {
5375 switch (flag)
5376 {
5377 case SHF_WRITE: *p = 'W'; break;
5378 case SHF_ALLOC: *p = 'A'; break;
5379 case SHF_EXECINSTR: *p = 'X'; break;
5380 case SHF_MERGE: *p = 'M'; break;
5381 case SHF_STRINGS: *p = 'S'; break;
5382 case SHF_INFO_LINK: *p = 'I'; break;
5383 case SHF_LINK_ORDER: *p = 'L'; break;
5384 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5385 case SHF_GROUP: *p = 'G'; break;
5386 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5387 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5388 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5389
5390 default:
8a9036a4 5391 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5392 || elf_header.e_machine == EM_L1OM
5393 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5394 && flag == SHF_X86_64_LARGE)
5395 *p = 'l';
5396 else if (flag & SHF_MASKOS)
5397 {
5398 *p = 'o';
5399 sh_flags &= ~ SHF_MASKOS;
5400 }
5401 else if (flag & SHF_MASKPROC)
5402 {
5403 *p = 'p';
5404 sh_flags &= ~ SHF_MASKPROC;
5405 }
5406 else
5407 *p = 'x';
5408 break;
5409 }
5410 p++;
d1133906
NC		 5411 }
5412 }
76da6bbe 5413
8d5ff12c
L		 5414 if (do_section_details)
5415 {
5416 if (os_flags)
5417 {
5418 size -= 5 + field_size;
5419 if (p != buff + field_size + 4)
5420 {
5421 if (size < (2 + 1))
bee0ee85
NC		 5422 {
5423 warn (_("Internal error: not enough buffer room for section flag info"));
5424 return _("<unknown>");
5425 }
8d5ff12c
L		 5426 size -= 2;
5427 *p++ = ',';
5428 *p++ = ' ';
5429 }
5430 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5431 (unsigned long) os_flags);
5432 p += 5 + field_size;
5433 }
5434 if (proc_flags)
5435 {
5436 size -= 7 + field_size;
5437 if (p != buff + field_size + 4)
5438 {
5439 if (size < (2 + 1))
bee0ee85
NC		 5440 {
5441 warn (_("Internal error: not enough buffer room for section flag info"));
5442 return _("<unknown>");
5443 }
8d5ff12c
L		 5444 size -= 2;
5445 *p++ = ',';
5446 *p++ = ' ';
5447 }
5448 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5449 (unsigned long) proc_flags);
5450 p += 7 + field_size;
5451 }
5452 if (unknown_flags)
5453 {
5454 size -= 10 + field_size;
5455 if (p != buff + field_size + 4)
5456 {
5457 if (size < (2 + 1))
bee0ee85
NC		 5458 {
5459 warn (_("Internal error: not enough buffer room for section flag info"));
5460 return _("<unknown>");
5461 }
8d5ff12c
L		 5462 size -= 2;
5463 *p++ = ',';
5464 *p++ = ' ';
5465 }
2b692964 5466 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5467 (unsigned long) unknown_flags);
5468 p += 10 + field_size;
5469 }
5470 }
5471
e9e44622 5472 *p = '\0';
d1133906
NC		 5473 return buff;
5474}
5475
77115a4a
L		 5476static unsigned int
5477get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5478{
5479 if (is_32bit_elf)
5480 {
5481 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5482 chdr->ch_type = BYTE_GET (echdr->ch_type);
5483 chdr->ch_size = BYTE_GET (echdr->ch_size);
5484 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5485 return sizeof (*echdr);
5486 }
5487 else
5488 {
5489 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5490 chdr->ch_type = BYTE_GET (echdr->ch_type);
5491 chdr->ch_size = BYTE_GET (echdr->ch_size);
5492 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5493 return sizeof (*echdr);
5494 }
5495}
5496
252b5132 5497static int
2cf0635d 5498process_section_headers (FILE * file)
252b5132 5499{
2cf0635d 5500 Elf_Internal_Shdr * section;
b34976b6 5501 unsigned int i;
252b5132
RH		 5502
5503 section_headers = NULL;
5504
5505 if (elf_header.e_shnum == 0)
5506 {
82f2dbf7
NC		 5507 /* PR binutils/12467. */
5508 if (elf_header.e_shoff != 0)
5509 warn (_("possibly corrupt ELF file header - it has a non-zero"
5510 " section header offset, but no section headers\n"));
5511 else if (do_sections)
252b5132
RH		 5512 printf (_("\nThere are no sections in this file.\n"));
5513
5514 return 1;
5515 }
5516
5517 if (do_sections && !do_header)
9ea033b2 5518 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5519 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5520
9ea033b2
NC		 5521 if (is_32bit_elf)
5522 {
049b0c3a 5523 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5524 return 0;
5525 }
049b0c3a 5526 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5527 return 0;
5528
5529 /* Read in the string table, so that we have names to display. */
0b49d371 5530 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5531 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5532 {
4fbb74a6 5533 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5534
c256ffe7
JJ		 5535 if (section->sh_size != 0)
5536 {
3f5e193b
NC		 5537 string_table = (char *) get_data (NULL, file, section->sh_offset,
5538 1, section->sh_size,
5539 _("string table"));
0de14b54 5540
c256ffe7
JJ		 5541 string_table_length = string_table != NULL ? section->sh_size : 0;
5542 }
252b5132
RH		 5543 }
5544
5545 /* Scan the sections for the dynamic symbol table
e3c8793a 5546 and dynamic string table and debug sections. */
252b5132
RH		 5547 dynamic_symbols = NULL;
5548 dynamic_strings = NULL;
5549 dynamic_syminfo = NULL;
6a40cf0c 5550 symtab_shndx_list = NULL;
103f02d3 5551
89fac5e3
RS		 5552 eh_addr_size = is_32bit_elf ? 4 : 8;
5553 switch (elf_header.e_machine)
5554 {
5555 case EM_MIPS:
5556 case EM_MIPS_RS3_LE:
5557 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5558 FDE addresses. However, the ABI also has a semi-official ILP32
5559 variant for which the normal FDE address size rules apply.
5560
5561 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5562 section, where XX is the size of longs in bits. Unfortunately,
5563 earlier compilers provided no way of distinguishing ILP32 objects
5564 from LP64 objects, so if there's any doubt, we should assume that
5565 the official LP64 form is being used. */
5566 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5567 && find_section (".gcc_compiled_long32") == NULL)
5568 eh_addr_size = 8;
5569 break;
0f56a26a
DD		 5570
5571 case EM_H8_300:
5572 case EM_H8_300H:
5573 switch (elf_header.e_flags & EF_H8_MACH)
5574 {
5575 case E_H8_MACH_H8300:
5576 case E_H8_MACH_H8300HN:
5577 case E_H8_MACH_H8300SN:
5578 case E_H8_MACH_H8300SXN:
5579 eh_addr_size = 2;
5580 break;
5581 case E_H8_MACH_H8300H:
5582 case E_H8_MACH_H8300S:
5583 case E_H8_MACH_H8300SX:
5584 eh_addr_size = 4;
5585 break;
5586 }
f4236fe4
DD		 5587 break;
5588
ff7eeb89 5589 case EM_M32C_OLD:
f4236fe4
DD		 5590 case EM_M32C:
5591 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5592 {
5593 case EF_M32C_CPU_M16C:
5594 eh_addr_size = 2;
5595 break;
5596 }
5597 break;
89fac5e3
RS		 5598 }
5599
76ca31c0
NC		 5600#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5601 do \
5602 { \
5603 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5604 if (section->sh_entsize != expected_entsize) \
9dd3a467 5605 { \
76ca31c0
NC		 5606 char buf[40]; \
5607 sprintf_vma (buf, section->sh_entsize); \
5608 /* Note: coded this way so that there is a single string for \
5609 translation. */ \
5610 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5611 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5612 (unsigned) expected_entsize); \
9dd3a467 5613 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5614 } \
5615 } \
08d8fa11 5616 while (0)
9dd3a467
NC		 5617
5618#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5619 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5620 sizeof (Elf64_External_##type))
5621
252b5132
RH		 5622 for (i = 0, section = section_headers;
5623 i < elf_header.e_shnum;
b34976b6 5624 i++, section++)
252b5132 5625 {
2cf0635d 5626 char * name = SECTION_NAME (section);
252b5132
RH		 5627
5628 if (section->sh_type == SHT_DYNSYM)
5629 {
5630 if (dynamic_symbols != NULL)
5631 {
5632 error (_("File contains multiple dynamic symbol tables\n"));
5633 continue;
5634 }
5635
08d8fa11 5636 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5637 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5638 }
5639 else if (section->sh_type == SHT_STRTAB
18bd398b 5640 && streq (name, ".dynstr"))
252b5132
RH		 5641 {
5642 if (dynamic_strings != NULL)
5643 {
5644 error (_("File contains multiple dynamic string tables\n"));
5645 continue;
5646 }
5647
3f5e193b
NC		 5648 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5649 1, section->sh_size,
5650 _("dynamic strings"));
59245841 5651 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5652 }
9ad5cbcf
AM		 5653 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5654 {
6a40cf0c
NC		 5655 elf_section_list * entry = xmalloc (sizeof * entry);
5656 entry->hdr = section;
5657 entry->next = symtab_shndx_list;
5658 symtab_shndx_list = entry;
9ad5cbcf 5659 }
08d8fa11
JJ		 5660 else if (section->sh_type == SHT_SYMTAB)
5661 CHECK_ENTSIZE (section, i, Sym);
5662 else if (section->sh_type == SHT_GROUP)
5663 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5664 else if (section->sh_type == SHT_REL)
5665 CHECK_ENTSIZE (section, i, Rel);
5666 else if (section->sh_type == SHT_RELA)
5667 CHECK_ENTSIZE (section, i, Rela);
252b5132 5668 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5669 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5670 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5671 || do_debug_str || do_debug_loc || do_debug_ranges
5672 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5673 && (const_strneq (name, ".debug_")
5674 || const_strneq (name, ".zdebug_")))
252b5132 5675 {
1b315056
CS		 5676 if (name[1] == 'z')
5677 name += sizeof (".zdebug_") - 1;
5678 else
5679 name += sizeof (".debug_") - 1;
252b5132
RH		 5680
5681 if (do_debugging
4723351a
CC		 5682 || (do_debug_info && const_strneq (name, "info"))
5683 || (do_debug_info && const_strneq (name, "types"))
5684 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5685 || (do_debug_lines && strcmp (name, "line") == 0)
5686 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5687 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5688 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5689 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5690 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5691 || (do_debug_aranges && const_strneq (name, "aranges"))
5692 || (do_debug_ranges && const_strneq (name, "ranges"))
5693 || (do_debug_frames && const_strneq (name, "frame"))
5694 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5695 || (do_debug_macinfo && const_strneq (name, "macro"))
5696 || (do_debug_str && const_strneq (name, "str"))
5697 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5698 || (do_debug_addr && const_strneq (name, "addr"))
5699 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5700 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5701 )
09c11c86 5702 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5703 }
a262ae96 5704 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5705 else if ((do_debugging || do_debug_info)
0112cd26 5706 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5707 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5708 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5709 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5710 else if (do_gdb_index && streq (name, ".gdb_index"))
5711 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5712 /* Trace sections for Itanium VMS. */
5713 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5714 || do_trace_aranges)
5715 && const_strneq (name, ".trace_"))
5716 {
5717 name += sizeof (".trace_") - 1;
5718
5719 if (do_debugging
5720 || (do_trace_info && streq (name, "info"))
5721 || (do_trace_abbrevs && streq (name, "abbrev"))
5722 || (do_trace_aranges && streq (name, "aranges"))
5723 )
5724 request_dump_bynumber (i, DEBUG_DUMP);
5725 }
252b5132
RH		 5726 }
5727
5728 if (! do_sections)
5729 return 1;
5730
3a1a2036
NC		 5731 if (elf_header.e_shnum > 1)
5732 printf (_("\nSection Headers:\n"));
5733 else
5734 printf (_("\nSection Header:\n"));
76da6bbe 5735
f7a99963 5736 if (is_32bit_elf)
595cf52e 5737 {
5477e8a0 5738 if (do_section_details)
595cf52e
L		 5739 {
5740 printf (_(" [Nr] Name\n"));
5477e8a0 5741 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5742 }
5743 else
5744 printf
5745 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5746 }
d974e256 5747 else if (do_wide)
595cf52e 5748 {
5477e8a0 5749 if (do_section_details)
595cf52e
L		 5750 {
5751 printf (_(" [Nr] Name\n"));
5477e8a0 5752 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5753 }
5754 else
5755 printf
5756 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5757 }
f7a99963
NC		 5758 else
5759 {
5477e8a0 5760 if (do_section_details)
595cf52e
L		 5761 {
5762 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5763 printf (_(" Type Address Offset Link\n"));
5764 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5765 }
5766 else
5767 {
5768 printf (_(" [Nr] Name Type Address Offset\n"));
5769 printf (_(" Size EntSize Flags Link Info Align\n"));
5770 }
f7a99963 5771 }
252b5132 5772
5477e8a0
L		 5773 if (do_section_details)
5774 printf (_(" Flags\n"));
5775
252b5132
RH		 5776 for (i = 0, section = section_headers;
5777 i < elf_header.e_shnum;
b34976b6 5778 i++, section++)
252b5132 5779 {
7bfd842d 5780 printf (" [%2u] ", i);
5477e8a0 5781 if (do_section_details)
74e1a04b 5782 printf ("%s\n ", printable_section_name (section));
595cf52e 5783 else
74e1a04b 5784 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5785
ea52a088
NC		 5786 printf (do_wide ? " %-15s " : " %-15.15s ",
5787 get_section_type_name (section->sh_type));
0b4362b0 5788
f7a99963
NC		 5789 if (is_32bit_elf)
5790 {
cfcac11d
NC		 5791 const char * link_too_big = NULL;
5792
f7a99963 5793 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5794
f7a99963
NC		 5795 printf ( " %6.6lx %6.6lx %2.2lx",
5796 (unsigned long) section->sh_offset,
5797 (unsigned long) section->sh_size,
5798 (unsigned long) section->sh_entsize);
d1133906 5799
5477e8a0
L		 5800 if (do_section_details)
5801 fputs (" ", stdout);
5802 else
5803 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5804
cfcac11d
NC		 5805 if (section->sh_link >= elf_header.e_shnum)
5806 {
5807 link_too_big = "";
5808 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5809 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5810 switch (elf_header.e_machine)
5811 {
caa83f8b 5812 case EM_386:
22abe556 5813 case EM_IAMCU:
caa83f8b 5814 case EM_X86_64:
7f502d6c 5815 case EM_L1OM:
7a9068fe 5816 case EM_K1OM:
cfcac11d
NC		 5817 case EM_OLD_SPARCV9:
5818 case EM_SPARC32PLUS:
5819 case EM_SPARCV9:
5820 case EM_SPARC:
5821 if (section->sh_link == (SHN_BEFORE & 0xffff))
5822 link_too_big = "BEFORE";
5823 else if (section->sh_link == (SHN_AFTER & 0xffff))
5824 link_too_big = "AFTER";
5825 break;
5826 default:
5827 break;
5828 }
5829 }
5830
5831 if (do_section_details)
5832 {
5833 if (link_too_big != NULL && * link_too_big)
5834 printf ("<%s> ", link_too_big);
5835 else
5836 printf ("%2u ", section->sh_link);
5837 printf ("%3u %2lu\n", section->sh_info,
5838 (unsigned long) section->sh_addralign);
5839 }
5840 else
5841 printf ("%2u %3u %2lu\n",
5842 section->sh_link,
5843 section->sh_info,
5844 (unsigned long) section->sh_addralign);
5845
5846 if (link_too_big && ! * link_too_big)
5847 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5848 i, section->sh_link);
f7a99963 5849 }
d974e256
JJ		 5850 else if (do_wide)
5851 {
5852 print_vma (section->sh_addr, LONG_HEX);
5853
5854 if ((long) section->sh_offset == section->sh_offset)
5855 printf (" %6.6lx", (unsigned long) section->sh_offset);
5856 else
5857 {
5858 putchar (' ');
5859 print_vma (section->sh_offset, LONG_HEX);
5860 }
5861
5862 if ((unsigned long) section->sh_size == section->sh_size)
5863 printf (" %6.6lx", (unsigned long) section->sh_size);
5864 else
5865 {
5866 putchar (' ');
5867 print_vma (section->sh_size, LONG_HEX);
5868 }
5869
5870 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5871 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5872 else
5873 {
5874 putchar (' ');
5875 print_vma (section->sh_entsize, LONG_HEX);
5876 }
5877
5477e8a0
L		 5878 if (do_section_details)
5879 fputs (" ", stdout);
5880 else
5881 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5882
72de5009 5883 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5884
5885 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5886 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5887 else
5888 {
5889 print_vma (section->sh_addralign, DEC);
5890 putchar ('\n');
5891 }
5892 }
5477e8a0 5893 else if (do_section_details)
595cf52e 5894 {
5477e8a0 5895 printf (" %-15.15s ",
595cf52e 5896 get_section_type_name (section->sh_type));
595cf52e
L		 5897 print_vma (section->sh_addr, LONG_HEX);
5898 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5899 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5900 else
5901 {
5902 printf (" ");
5903 print_vma (section->sh_offset, LONG_HEX);
5904 }
72de5009 5905 printf (" %u\n ", section->sh_link);
595cf52e 5906 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5907 putchar (' ');
595cf52e
L		 5908 print_vma (section->sh_entsize, LONG_HEX);
5909
72de5009
AM		 5910 printf (" %-16u %lu\n",
5911 section->sh_info,
595cf52e
L		 5912 (unsigned long) section->sh_addralign);
5913 }
f7a99963
NC		 5914 else
5915 {
5916 putchar (' ');
5917 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5918 if ((long) section->sh_offset == section->sh_offset)
5919 printf (" %8.8lx", (unsigned long) section->sh_offset);
5920 else
5921 {
5922 printf (" ");
5923 print_vma (section->sh_offset, LONG_HEX);
5924 }
f7a99963
NC		 5925 printf ("\n ");
5926 print_vma (section->sh_size, LONG_HEX);
5927 printf (" ");
5928 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5929
d1133906 5930 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5931
72de5009
AM		 5932 printf (" %2u %3u %lu\n",
5933 section->sh_link,
5934 section->sh_info,
f7a99963
NC		 5935 (unsigned long) section->sh_addralign);
5936 }
5477e8a0
L		 5937
5938 if (do_section_details)
77115a4a
L		 5939 {
5940 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5941 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5942 {
5943 /* Minimum section size is 12 bytes for 32-bit compression
5944 header + 12 bytes for compressed data header. */
5945 unsigned char buf[24];
5946 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5947 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5948 sizeof (buf), _("compression header")))
5949 {
5950 Elf_Internal_Chdr chdr;
5951 get_compression_header (&chdr, buf);
5952 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5953 printf (" ZLIB, ");
5954 else
5955 printf (_(" [<unknown>: 0x%x], "),
5956 chdr.ch_type);
5957 print_vma (chdr.ch_size, LONG_HEX);
5958 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5959 }
5960 }
5961 }
252b5132
RH		 5962 }
5963
5477e8a0 5964 if (!do_section_details)
3dbcc61d
NC		 5965 {
5966 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5967 || elf_header.e_machine == EM_L1OM
5968 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5969 printf (_("Key to Flags:\n\
5970 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5971 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5972 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5973 else
5974 printf (_("Key to Flags:\n\
e3c8793a 5975 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5976 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5977 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5978 }
d1133906 5979
252b5132
RH		 5980 return 1;
5981}
5982
f5842774
L		 5983static const char *
5984get_group_flags (unsigned int flags)
5985{
5986 static char buff[32];
5987 switch (flags)
5988 {
220453ec
AM		 5989 case 0:
5990 return "";
5991
f5842774 5992 case GRP_COMDAT:
220453ec 5993 return "COMDAT ";
f5842774
L		 5994
5995 default:
220453ec 5996 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5997 break;
5998 }
5999 return buff;
6000}
6001
6002static int
2cf0635d 6003process_section_groups (FILE * file)
f5842774 6004{
2cf0635d 6005 Elf_Internal_Shdr * section;
f5842774 6006 unsigned int i;
2cf0635d
NC		 6007 struct group * group;
6008 Elf_Internal_Shdr * symtab_sec;
6009 Elf_Internal_Shdr * strtab_sec;
6010 Elf_Internal_Sym * symtab;
ba5cdace 6011 unsigned long num_syms;
2cf0635d 6012 char * strtab;
c256ffe7 6013 size_t strtab_size;
d1f5c6e3
L		 6014
6015 /* Don't process section groups unless needed. */
6016 if (!do_unwind && !do_section_groups)
6017 return 1;
f5842774
L		 6018
6019 if (elf_header.e_shnum == 0)
6020 {
6021 if (do_section_groups)
82f2dbf7 6022 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6023
6024 return 1;
6025 }
6026
6027 if (section_headers == NULL)
6028 {
6029 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6030 /* PR 13622: This can happen with a corrupt ELF header. */
6031 return 0;
f5842774
L		 6032 }
6033
3f5e193b
NC		 6034 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6035 sizeof (struct group *));
e4b17d5c
L		 6036
6037 if (section_headers_groups == NULL)
6038 {
8b73c356
NC		 6039 error (_("Out of memory reading %u section group headers\n"),
6040 elf_header.e_shnum);
e4b17d5c
L		 6041 return 0;
6042 }
6043
f5842774 6044 /* Scan the sections for the group section. */
d1f5c6e3 6045 group_count = 0;
f5842774
L		 6046 for (i = 0, section = section_headers;
6047 i < elf_header.e_shnum;
6048 i++, section++)
e4b17d5c
L		 6049 if (section->sh_type == SHT_GROUP)
6050 group_count++;
6051
d1f5c6e3
L		 6052 if (group_count == 0)
6053 {
6054 if (do_section_groups)
6055 printf (_("\nThere are no section groups in this file.\n"));
6056
6057 return 1;
6058 }
6059
3f5e193b 6060 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6061
6062 if (section_groups == NULL)
6063 {
8b73c356
NC		 6064 error (_("Out of memory reading %lu groups\n"),
6065 (unsigned long) group_count);
e4b17d5c
L		 6066 return 0;
6067 }
6068
d1f5c6e3
L		 6069 symtab_sec = NULL;
6070 strtab_sec = NULL;
6071 symtab = NULL;
ba5cdace 6072 num_syms = 0;
d1f5c6e3 6073 strtab = NULL;
c256ffe7 6074 strtab_size = 0;
e4b17d5c
L		 6075 for (i = 0, section = section_headers, group = section_groups;
6076 i < elf_header.e_shnum;
6077 i++, section++)
f5842774
L		 6078 {
6079 if (section->sh_type == SHT_GROUP)
6080 {
74e1a04b
NC		 6081 const char * name = printable_section_name (section);
6082 const char * group_name;
2cf0635d
NC		 6083 unsigned char * start;
6084 unsigned char * indices;
f5842774 6085 unsigned int entry, j, size;
2cf0635d
NC		 6086 Elf_Internal_Shdr * sec;
6087 Elf_Internal_Sym * sym;
f5842774
L		 6088
6089 /* Get the symbol table. */
4fbb74a6
AM		 6090 if (section->sh_link >= elf_header.e_shnum
6091 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6092 != SHT_SYMTAB))
f5842774
L		 6093 {
6094 error (_("Bad sh_link in group section `%s'\n"), name);
6095 continue;
6096 }
d1f5c6e3
L		 6097
6098 if (symtab_sec != sec)
6099 {
6100 symtab_sec = sec;
6101 if (symtab)
6102 free (symtab);
ba5cdace 6103 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6104 }
f5842774 6105
dd24e3da
NC		 6106 if (symtab == NULL)
6107 {
6108 error (_("Corrupt header in group section `%s'\n"), name);
6109 continue;
6110 }
6111
ba5cdace
NC		 6112 if (section->sh_info >= num_syms)
6113 {
6114 error (_("Bad sh_info in group section `%s'\n"), name);
6115 continue;
6116 }
6117
f5842774
L		 6118 sym = symtab + section->sh_info;
6119
6120 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6121 {
4fbb74a6
AM		 6122 if (sym->st_shndx == 0
6123 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6124 {
6125 error (_("Bad sh_info in group section `%s'\n"), name);
6126 continue;
6127 }
ba2685cc 6128
4fbb74a6 6129 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6130 strtab_sec = NULL;
6131 if (strtab)
6132 free (strtab);
f5842774 6133 strtab = NULL;
c256ffe7 6134 strtab_size = 0;
f5842774
L		 6135 }
6136 else
6137 {
6138 /* Get the string table. */
4fbb74a6 6139 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6140 {
6141 strtab_sec = NULL;
6142 if (strtab)
6143 free (strtab);
6144 strtab = NULL;
6145 strtab_size = 0;
6146 }
6147 else if (strtab_sec
4fbb74a6 6148 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6149 {
6150 strtab_sec = sec;
6151 if (strtab)
6152 free (strtab);
071436c6 6153
3f5e193b 6154 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6155 1, strtab_sec->sh_size,
6156 _("string table"));
c256ffe7 6157 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6158 }
c256ffe7 6159 group_name = sym->st_name < strtab_size
2b692964 6160 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6161 }
6162
c9c1d674
EG		 6163 /* PR 17531: file: loop. */
6164 if (section->sh_entsize > section->sh_size)
6165 {
6166 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6167 printable_section_name (section),
8066deb1
AM		 6168 (unsigned long) section->sh_entsize,
6169 (unsigned long) section->sh_size);
c9c1d674
EG		 6170 break;
6171 }
6172
3f5e193b
NC		 6173 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6174 1, section->sh_size,
6175 _("section data"));
59245841
NC		 6176 if (start == NULL)
6177 continue;
f5842774
L		 6178
6179 indices = start;
6180 size = (section->sh_size / section->sh_entsize) - 1;
6181 entry = byte_get (indices, 4);
6182 indices += 4;
e4b17d5c
L		 6183
6184 if (do_section_groups)
6185 {
2b692964 6186 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6187 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6188
e4b17d5c
L		 6189 printf (_(" [Index] Name\n"));
6190 }
6191
6192 group->group_index = i;
6193
f5842774
L		 6194 for (j = 0; j < size; j++)
6195 {
2cf0635d 6196 struct group_list * g;
e4b17d5c 6197
f5842774
L		 6198 entry = byte_get (indices, 4);
6199 indices += 4;
6200
4fbb74a6 6201 if (entry >= elf_header.e_shnum)
391cb864 6202 {
57028622
NC		 6203 static unsigned num_group_errors = 0;
6204
6205 if (num_group_errors ++ < 10)
6206 {
6207 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6208 entry, i, elf_header.e_shnum - 1);
6209 if (num_group_errors == 10)
6210 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6211 }
391cb864
L		 6212 continue;
6213 }
391cb864 6214
4fbb74a6 6215 if (section_headers_groups [entry] != NULL)
e4b17d5c 6216 {
d1f5c6e3
L		 6217 if (entry)
6218 {
57028622
NC		 6219 static unsigned num_errs = 0;
6220
6221 if (num_errs ++ < 10)
6222 {
6223 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6224 entry, i,
6225 section_headers_groups [entry]->group_index);
6226 if (num_errs == 10)
6227 warn (_("Further error messages about already contained group sections suppressed\n"));
6228 }
d1f5c6e3
L		 6229 continue;
6230 }
6231 else
6232 {
6233 /* Intel C/C++ compiler may put section 0 in a
6234 section group. We just warn it the first time
6235 and ignore it afterwards. */
6236 static int warned = 0;
6237 if (!warned)
6238 {
6239 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6240 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6241 warned++;
6242 }
6243 }
e4b17d5c
L		 6244 }
6245
4fbb74a6 6246 section_headers_groups [entry] = group;
e4b17d5c
L		 6247
6248 if (do_section_groups)
6249 {
4fbb74a6 6250 sec = section_headers + entry;
74e1a04b 6251 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6252 }
6253
3f5e193b 6254 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6255 g->section_index = entry;
6256 g->next = group->root;
6257 group->root = g;
f5842774
L		 6258 }
6259
f5842774
L		 6260 if (start)
6261 free (start);
e4b17d5c
L		 6262
6263 group++;
f5842774
L		 6264 }
6265 }
6266
d1f5c6e3
L		 6267 if (symtab)
6268 free (symtab);
6269 if (strtab)
6270 free (strtab);
f5842774
L		 6271 return 1;
6272}
6273
28f997cf
TG		 6274/* Data used to display dynamic fixups. */
6275
6276struct ia64_vms_dynfixup
6277{
6278 bfd_vma needed_ident; /* Library ident number. */
6279 bfd_vma needed; /* Index in the dstrtab of the library name. */
6280 bfd_vma fixup_needed; /* Index of the library. */
6281 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6282 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6283};
6284
6285/* Data used to display dynamic relocations. */
6286
6287struct ia64_vms_dynimgrela
6288{
6289 bfd_vma img_rela_cnt; /* Number of relocations. */
6290 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6291};
6292
6293/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6294 library). */
6295
6296static void
6297dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6298 const char *strtab, unsigned int strtab_sz)
6299{
6300 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6301 long i;
6302 const char *lib_name;
6303
6304 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6305 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6306 _("dynamic section image fixups"));
6307 if (!imfs)
6308 return;
6309
6310 if (fixup->needed < strtab_sz)
6311 lib_name = strtab + fixup->needed;
6312 else
6313 {
6314 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6315 (unsigned long) fixup->needed);
28f997cf
TG		 6316 lib_name = "???";
6317 }
6318 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6319 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6320 printf
6321 (_("Seg Offset Type SymVec DataType\n"));
6322
6323 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6324 {
6325 unsigned int type;
6326 const char *rtype;
6327
6328 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6329 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6330 type = BYTE_GET (imfs [i].type);
6331 rtype = elf_ia64_reloc_type (type);
6332 if (rtype == NULL)
6333 printf (" 0x%08x ", type);
6334 else
6335 printf (" %-32s ", rtype);
6336 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6337 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6338 }
6339
6340 free (imfs);
6341}
6342
6343/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6344
6345static void
6346dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6347{
6348 Elf64_External_VMS_IMAGE_RELA *imrs;
6349 long i;
6350
6351 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6352 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6353 _("dynamic section image relocations"));
28f997cf
TG		 6354 if (!imrs)
6355 return;
6356
6357 printf (_("\nImage relocs\n"));
6358 printf
6359 (_("Seg Offset Type Addend Seg Sym Off\n"));
6360
6361 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6362 {
6363 unsigned int type;
6364 const char *rtype;
6365
6366 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6367 printf ("%08" BFD_VMA_FMT "x ",
6368 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6369 type = BYTE_GET (imrs [i].type);
6370 rtype = elf_ia64_reloc_type (type);
6371 if (rtype == NULL)
6372 printf ("0x%08x ", type);
6373 else
6374 printf ("%-31s ", rtype);
6375 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6376 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6377 printf ("%08" BFD_VMA_FMT "x\n",
6378 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6379 }
6380
6381 free (imrs);
6382}
6383
6384/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6385
6386static int
6387process_ia64_vms_dynamic_relocs (FILE *file)
6388{
6389 struct ia64_vms_dynfixup fixup;
6390 struct ia64_vms_dynimgrela imgrela;
6391 Elf_Internal_Dyn *entry;
6392 int res = 0;
6393 bfd_vma strtab_off = 0;
6394 bfd_vma strtab_sz = 0;
6395 char *strtab = NULL;
6396
6397 memset (&fixup, 0, sizeof (fixup));
6398 memset (&imgrela, 0, sizeof (imgrela));
6399
6400 /* Note: the order of the entries is specified by the OpenVMS specs. */
6401 for (entry = dynamic_section;
6402 entry < dynamic_section + dynamic_nent;
6403 entry++)
6404 {
6405 switch (entry->d_tag)
6406 {
6407 case DT_IA_64_VMS_STRTAB_OFFSET:
6408 strtab_off = entry->d_un.d_val;
6409 break;
6410 case DT_STRSZ:
6411 strtab_sz = entry->d_un.d_val;
6412 if (strtab == NULL)
6413 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6414 1, strtab_sz, _("dynamic string section"));
6415 break;
6416
6417 case DT_IA_64_VMS_NEEDED_IDENT:
6418 fixup.needed_ident = entry->d_un.d_val;
6419 break;
6420 case DT_NEEDED:
6421 fixup.needed = entry->d_un.d_val;
6422 break;
6423 case DT_IA_64_VMS_FIXUP_NEEDED:
6424 fixup.fixup_needed = entry->d_un.d_val;
6425 break;
6426 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6427 fixup.fixup_rela_cnt = entry->d_un.d_val;
6428 break;
6429 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6430 fixup.fixup_rela_off = entry->d_un.d_val;
6431 res++;
6432 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6433 break;
6434
6435 case DT_IA_64_VMS_IMG_RELA_CNT:
6436 imgrela.img_rela_cnt = entry->d_un.d_val;
6437 break;
6438 case DT_IA_64_VMS_IMG_RELA_OFF:
6439 imgrela.img_rela_off = entry->d_un.d_val;
6440 res++;
6441 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6442 break;
6443
6444 default:
6445 break;
6446 }
6447 }
6448
6449 if (strtab != NULL)
6450 free (strtab);
6451
6452 return res;
6453}
6454
85b1c36d 6455static struct
566b0d53 6456{
2cf0635d 6457 const char * name;
566b0d53
L		 6458 int reloc;
6459 int size;
6460 int rela;
6461} dynamic_relocations [] =
6462{
6463 { "REL", DT_REL, DT_RELSZ, FALSE },
6464 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6465 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6466};
6467
252b5132 6468/* Process the reloc section. */
18bd398b 6469
252b5132 6470static int
2cf0635d 6471process_relocs (FILE * file)
252b5132 6472{
b34976b6
AM		 6473 unsigned long rel_size;
6474 unsigned long rel_offset;
252b5132
RH		 6475
6476
6477 if (!do_reloc)
6478 return 1;
6479
6480 if (do_using_dynamic)
6481 {
566b0d53 6482 int is_rela;
2cf0635d 6483 const char * name;
566b0d53
L		 6484 int has_dynamic_reloc;
6485 unsigned int i;
0de14b54 6486
566b0d53 6487 has_dynamic_reloc = 0;
252b5132 6488
566b0d53 6489 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6490 {
566b0d53
L		 6491 is_rela = dynamic_relocations [i].rela;
6492 name = dynamic_relocations [i].name;
6493 rel_size = dynamic_info [dynamic_relocations [i].size];
6494 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6495
566b0d53
L		 6496 has_dynamic_reloc |= rel_size;
6497
6498 if (is_rela == UNKNOWN)
aa903cfb 6499 {
566b0d53
L		 6500 if (dynamic_relocations [i].reloc == DT_JMPREL)
6501 switch (dynamic_info[DT_PLTREL])
6502 {
6503 case DT_REL:
6504 is_rela = FALSE;
6505 break;
6506 case DT_RELA:
6507 is_rela = TRUE;
6508 break;
6509 }
aa903cfb 6510 }
252b5132 6511
566b0d53
L		 6512 if (rel_size)
6513 {
6514 printf
6515 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6516 name, rel_offset, rel_size);
252b5132 6517
d93f0186
NC		 6518 dump_relocations (file,
6519 offset_from_vma (file, rel_offset, rel_size),
6520 rel_size,
566b0d53 6521 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6522 dynamic_strings, dynamic_strings_length,
6523 is_rela, 1);
566b0d53 6524 }
252b5132 6525 }
566b0d53 6526
28f997cf
TG		 6527 if (is_ia64_vms ())
6528 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6529
566b0d53 6530 if (! has_dynamic_reloc)
252b5132
RH		 6531 printf (_("\nThere are no dynamic relocations in this file.\n"));
6532 }
6533 else
6534 {
2cf0635d 6535 Elf_Internal_Shdr * section;
b34976b6
AM		 6536 unsigned long i;
6537 int found = 0;
252b5132
RH		 6538
6539 for (i = 0, section = section_headers;
6540 i < elf_header.e_shnum;
b34976b6 6541 i++, section++)
252b5132
RH		 6542 {
6543 if ( section->sh_type != SHT_RELA
6544 && section->sh_type != SHT_REL)
6545 continue;
6546
6547 rel_offset = section->sh_offset;
6548 rel_size = section->sh_size;
6549
6550 if (rel_size)
6551 {
2cf0635d 6552 Elf_Internal_Shdr * strsec;
b34976b6 6553 int is_rela;
103f02d3 6554
252b5132
RH		 6555 printf (_("\nRelocation section "));
6556
6557 if (string_table == NULL)
19936277 6558 printf ("%d", section->sh_name);
252b5132 6559 else
74e1a04b 6560 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6561
6562 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6563 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6564
d79b3d50
NC		 6565 is_rela = section->sh_type == SHT_RELA;
6566
4fbb74a6
AM		 6567 if (section->sh_link != 0
6568 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6569 {
2cf0635d
NC		 6570 Elf_Internal_Shdr * symsec;
6571 Elf_Internal_Sym * symtab;
d79b3d50 6572 unsigned long nsyms;
c256ffe7 6573 unsigned long strtablen = 0;
2cf0635d 6574 char * strtab = NULL;
57346661 6575
4fbb74a6 6576 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6577 if (symsec->sh_type != SHT_SYMTAB
6578 && symsec->sh_type != SHT_DYNSYM)
6579 continue;
6580
ba5cdace 6581 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6582
af3fc3bc
AM		 6583 if (symtab == NULL)
6584 continue;
252b5132 6585
4fbb74a6
AM		 6586 if (symsec->sh_link != 0
6587 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6588 {
4fbb74a6 6589 strsec = section_headers + symsec->sh_link;
103f02d3 6590
3f5e193b 6591 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6592 1, strsec->sh_size,
6593 _("string table"));
c256ffe7
JJ		 6594 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6595 }
252b5132 6596
d79b3d50 6597 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6598 symtab, nsyms, strtab, strtablen,
6599 is_rela,
6600 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6601 if (strtab)
6602 free (strtab);
6603 free (symtab);
6604 }
6605 else
6606 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6607 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6608
6609 found = 1;
6610 }
6611 }
6612
6613 if (! found)
6614 printf (_("\nThere are no relocations in this file.\n"));
6615 }
6616
6617 return 1;
6618}
6619
4d6ed7c8
NC		 6620/* An absolute address consists of a section and an offset. If the
6621 section is NULL, the offset itself is the address, otherwise, the
6622 address equals to LOAD_ADDRESS(section) + offset. */
6623
6624struct absaddr
948f632f
DA		 6625{
6626 unsigned short section;
6627 bfd_vma offset;
6628};
4d6ed7c8 6629
1949de15
L		 6630#define ABSADDR(a) \
6631 ((a).section \
6632 ? section_headers [(a).section].sh_addr + (a).offset \
6633 : (a).offset)
6634
948f632f
DA		 6635/* Find the nearest symbol at or below ADDR. Returns the symbol
6636 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6637
4d6ed7c8 6638static void
2cf0635d 6639find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6640 unsigned long nsyms,
6641 const char * strtab,
6642 unsigned long strtab_size,
6643 struct absaddr addr,
6644 const char ** symname,
6645 bfd_vma * offset)
4d6ed7c8 6646{
d3ba0551 6647 bfd_vma dist = 0x100000;
2cf0635d 6648 Elf_Internal_Sym * sym;
948f632f
DA		 6649 Elf_Internal_Sym * beg;
6650 Elf_Internal_Sym * end;
2cf0635d 6651 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6652
0b6ae522 6653 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6654 beg = symtab;
6655 end = symtab + nsyms;
0b6ae522 6656
948f632f 6657 while (beg < end)
4d6ed7c8 6658 {
948f632f
DA		 6659 bfd_vma value;
6660
6661 sym = beg + (end - beg) / 2;
0b6ae522 6662
948f632f 6663 value = sym->st_value;
0b6ae522
DJ		 6664 REMOVE_ARCH_BITS (value);
6665
948f632f 6666 if (sym->st_name != 0
4d6ed7c8 6667 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6668 && addr.offset >= value
6669 && addr.offset - value < dist)
4d6ed7c8
NC		 6670 {
6671 best = sym;
0b6ae522 6672 dist = addr.offset - value;
4d6ed7c8
NC		 6673 if (!dist)
6674 break;
6675 }
948f632f
DA		 6676
6677 if (addr.offset < value)
6678 end = sym;
6679 else
6680 beg = sym + 1;
4d6ed7c8 6681 }
1b31d05e 6682
4d6ed7c8
NC		 6683 if (best)
6684 {
57346661 6685 *symname = (best->st_name >= strtab_size
2b692964 6686 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6687 *offset = dist;
6688 return;
6689 }
1b31d05e 6690
4d6ed7c8
NC		 6691 *symname = NULL;
6692 *offset = addr.offset;
6693}
6694
948f632f
DA		 6695static int
6696symcmp (const void *p, const void *q)
6697{
6698 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6699 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6700
6701 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6702}
6703
6704/* Process the unwind section. */
6705
6706#include "unwind-ia64.h"
6707
6708struct ia64_unw_table_entry
6709{
6710 struct absaddr start;
6711 struct absaddr end;
6712 struct absaddr info;
6713};
6714
6715struct ia64_unw_aux_info
6716{
6717 struct ia64_unw_table_entry *table; /* Unwind table. */
6718 unsigned long table_len; /* Length of unwind table. */
6719 unsigned char * info; /* Unwind info. */
6720 unsigned long info_size; /* Size of unwind info. */
6721 bfd_vma info_addr; /* Starting address of unwind info. */
6722 bfd_vma seg_base; /* Starting address of segment. */
6723 Elf_Internal_Sym * symtab; /* The symbol table. */
6724 unsigned long nsyms; /* Number of symbols. */
6725 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6726 unsigned long nfuns; /* Number of entries in funtab. */
6727 char * strtab; /* The string table. */
6728 unsigned long strtab_size; /* Size of string table. */
6729};
6730
4d6ed7c8 6731static void
2cf0635d 6732dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6733{
2cf0635d 6734 struct ia64_unw_table_entry * tp;
948f632f 6735 unsigned long j, nfuns;
4d6ed7c8 6736 int in_body;
7036c0e1 6737
948f632f
DA		 6738 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6739 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6740 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6741 aux->funtab[nfuns++] = aux->symtab[j];
6742 aux->nfuns = nfuns;
6743 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6744
4d6ed7c8
NC		 6745 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6746 {
6747 bfd_vma stamp;
6748 bfd_vma offset;
2cf0635d
NC		 6749 const unsigned char * dp;
6750 const unsigned char * head;
53774b7e 6751 const unsigned char * end;
2cf0635d 6752 const char * procname;
4d6ed7c8 6753
948f632f 6754 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6755 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6756
6757 fputs ("\n<", stdout);
6758
6759 if (procname)
6760 {
6761 fputs (procname, stdout);
6762
6763 if (offset)
6764 printf ("+%lx", (unsigned long) offset);
6765 }
6766
6767 fputs (">: [", stdout);
6768 print_vma (tp->start.offset, PREFIX_HEX);
6769 fputc ('-', stdout);
6770 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6771 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6772 (unsigned long) (tp->info.offset - aux->seg_base));
6773
53774b7e
NC		 6774 /* PR 17531: file: 86232b32. */
6775 if (aux->info == NULL)
6776 continue;
6777
6778 /* PR 17531: file: 0997b4d1. */
6779 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6780 {
6781 warn (_("Invalid offset %lx in table entry %ld\n"),
6782 (long) tp->info.offset, (long) (tp - aux->table));
6783 continue;
6784 }
6785
1949de15 6786 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6787 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6788
86f55779 6789 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6790 (unsigned) UNW_VER (stamp),
6791 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6792 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6793 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6794 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6795
6796 if (UNW_VER (stamp) != 1)
6797 {
2b692964 6798 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6799 continue;
6800 }
6801
6802 in_body = 0;
53774b7e
NC		 6803 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6804 /* PR 17531: file: 16ceda89. */
6805 if (end > aux->info + aux->info_size)
6806 end = aux->info + aux->info_size;
6807 for (dp = head + 8; dp < end;)
b4477bc8 6808 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6809 }
948f632f
DA		 6810
6811 free (aux->funtab);
4d6ed7c8
NC		 6812}
6813
53774b7e 6814static bfd_boolean
2cf0635d
NC		 6815slurp_ia64_unwind_table (FILE * file,
6816 struct ia64_unw_aux_info * aux,
6817 Elf_Internal_Shdr * sec)
4d6ed7c8 6818{
89fac5e3 6819 unsigned long size, nrelas, i;
2cf0635d
NC		 6820 Elf_Internal_Phdr * seg;
6821 struct ia64_unw_table_entry * tep;
6822 Elf_Internal_Shdr * relsec;
6823 Elf_Internal_Rela * rela;
6824 Elf_Internal_Rela * rp;
6825 unsigned char * table;
6826 unsigned char * tp;
6827 Elf_Internal_Sym * sym;
6828 const char * relname;
4d6ed7c8 6829
53774b7e
NC		 6830 aux->table_len = 0;
6831
4d6ed7c8
NC		 6832 /* First, find the starting address of the segment that includes
6833 this section: */
6834
6835 if (elf_header.e_phnum)
6836 {
d93f0186 6837 if (! get_program_headers (file))
53774b7e 6838 return FALSE;
4d6ed7c8 6839
d93f0186
NC		 6840 for (seg = program_headers;
6841 seg < program_headers + elf_header.e_phnum;
6842 ++seg)
4d6ed7c8
NC		 6843 {
6844 if (seg->p_type != PT_LOAD)
6845 continue;
6846
6847 if (sec->sh_addr >= seg->p_vaddr
6848 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6849 {
6850 aux->seg_base = seg->p_vaddr;
6851 break;
6852 }
6853 }
4d6ed7c8
NC		 6854 }
6855
6856 /* Second, build the unwind table from the contents of the unwind section: */
6857 size = sec->sh_size;
3f5e193b
NC		 6858 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6859 _("unwind table"));
a6e9f9df 6860 if (!table)
53774b7e 6861 return FALSE;
4d6ed7c8 6862
53774b7e 6863 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6864 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6865 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6866 tep = aux->table;
53774b7e
NC		 6867
6868 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6869 {
6870 tep->start.section = SHN_UNDEF;
6871 tep->end.section = SHN_UNDEF;
6872 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6873 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6874 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6875 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6876 tep->start.offset += aux->seg_base;
6877 tep->end.offset += aux->seg_base;
6878 tep->info.offset += aux->seg_base;
6879 }
6880 free (table);
6881
41e92641 6882 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6883 for (relsec = section_headers;
6884 relsec < section_headers + elf_header.e_shnum;
6885 ++relsec)
6886 {
6887 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6888 || relsec->sh_info >= elf_header.e_shnum
6889 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6890 continue;
6891
6892 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6893 & rela, & nrelas))
53774b7e
NC		 6894 {
6895 free (aux->table);
6896 aux->table = NULL;
6897 aux->table_len = 0;
6898 return FALSE;
6899 }
4d6ed7c8
NC		 6900
6901 for (rp = rela; rp < rela + nrelas; ++rp)
6902 {
aca88567
NC		 6903 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6904 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6905
82b1b41b
NC		 6906 /* PR 17531: file: 9fa67536. */
6907 if (relname == NULL)
6908 {
6909 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6910 continue;
6911 }
948f632f 6912
0112cd26 6913 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6914 {
82b1b41b 6915 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6916 continue;
6917 }
6918
89fac5e3 6919 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6920
53774b7e
NC		 6921 /* PR 17531: file: 5bc8d9bf. */
6922 if (i >= aux->table_len)
6923 {
6924 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6925 continue;
6926 }
6927
6928 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6929 {
6930 case 0:
6931 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6932 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6933 break;
6934 case 1:
6935 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6936 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6937 break;
6938 case 2:
6939 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6940 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6941 break;
6942 default:
6943 break;
6944 }
6945 }
6946
6947 free (rela);
6948 }
6949
53774b7e 6950 return TRUE;
4d6ed7c8
NC		 6951}
6952
1b31d05e 6953static void
2cf0635d 6954ia64_process_unwind (FILE * file)
4d6ed7c8 6955{
2cf0635d
NC		 6956 Elf_Internal_Shdr * sec;
6957 Elf_Internal_Shdr * unwsec = NULL;
6958 Elf_Internal_Shdr * strsec;
89fac5e3 6959 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6960 struct ia64_unw_aux_info aux;
f1467e33 6961
4d6ed7c8
NC		 6962 memset (& aux, 0, sizeof (aux));
6963
4d6ed7c8
NC		 6964 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6965 {
c256ffe7 6966 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6967 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6968 {
ba5cdace 6969 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6970
4fbb74a6 6971 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6972 if (aux.strtab != NULL)
6973 {
6974 error (_("Multiple auxillary string tables encountered\n"));
6975 free (aux.strtab);
6976 }
3f5e193b
NC		 6977 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6978 1, strsec->sh_size,
6979 _("string table"));
c256ffe7 6980 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6981 }
6982 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6983 unwcount++;
6984 }
6985
6986 if (!unwcount)
6987 printf (_("\nThere are no unwind sections in this file.\n"));
6988
6989 while (unwcount-- > 0)
6990 {
2cf0635d 6991 char * suffix;
579f31ac
JJ		 6992 size_t len, len2;
6993
4082ef84 6994 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6995 i < elf_header.e_shnum; ++i, ++sec)
6996 if (sec->sh_type == SHT_IA_64_UNWIND)
6997 {
6998 unwsec = sec;
6999 break;
7000 }
4082ef84
NC		 7001 /* We have already counted the number of SHT_IA64_UNWIND
7002 sections so the loop above should never fail. */
7003 assert (unwsec != NULL);
579f31ac
JJ		 7004
7005 unwstart = i + 1;
7006 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7007
e4b17d5c
L		 7008 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7009 {
7010 /* We need to find which section group it is in. */
4082ef84 7011 struct group_list * g;
e4b17d5c 7012
4082ef84
NC		 7013 if (section_headers_groups == NULL
7014 || section_headers_groups [i] == NULL)
7015 i = elf_header.e_shnum;
7016 else
e4b17d5c 7017 {
4082ef84 7018 g = section_headers_groups [i]->root;
18bd398b 7019
4082ef84
NC		 7020 for (; g != NULL; g = g->next)
7021 {
7022 sec = section_headers + g->section_index;
e4b17d5c 7023
4082ef84
NC		 7024 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7025 break;
7026 }
7027
7028 if (g == NULL)
7029 i = elf_header.e_shnum;
7030 }
e4b17d5c 7031 }
18bd398b 7032 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7033 {
18bd398b 7034 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7035 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7036 suffix = SECTION_NAME (unwsec) + len;
7037 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7038 ++i, ++sec)
18bd398b
NC		 7039 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7040 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7041 break;
7042 }
7043 else
7044 {
7045 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7046 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7047 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7048 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7049 suffix = "";
18bd398b 7050 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7051 suffix = SECTION_NAME (unwsec) + len;
7052 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7053 ++i, ++sec)
18bd398b
NC		 7054 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7055 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7056 break;
7057 }
7058
7059 if (i == elf_header.e_shnum)
7060 {
7061 printf (_("\nCould not find unwind info section for "));
7062
7063 if (string_table == NULL)
7064 printf ("%d", unwsec->sh_name);
7065 else
74e1a04b 7066 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7067 }
7068 else
4d6ed7c8 7069 {
4d6ed7c8 7070 aux.info_addr = sec->sh_addr;
3f5e193b 7071 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7072 sec->sh_size,
7073 _("unwind info"));
59245841 7074 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7075
579f31ac 7076 printf (_("\nUnwind section "));
4d6ed7c8 7077
579f31ac
JJ		 7078 if (string_table == NULL)
7079 printf ("%d", unwsec->sh_name);
7080 else
74e1a04b 7081 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7082
579f31ac 7083 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7084 (unsigned long) unwsec->sh_offset,
89fac5e3 7085 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7086
53774b7e
NC		 7087 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7088 && aux.table_len > 0)
579f31ac
JJ		 7089 dump_ia64_unwind (& aux);
7090
7091 if (aux.table)
7092 free ((char *) aux.table);
7093 if (aux.info)
7094 free ((char *) aux.info);
7095 aux.table = NULL;
7096 aux.info = NULL;
7097 }
4d6ed7c8 7098 }
4d6ed7c8 7099
4d6ed7c8
NC		 7100 if (aux.symtab)
7101 free (aux.symtab);
7102 if (aux.strtab)
7103 free ((char *) aux.strtab);
4d6ed7c8
NC		 7104}
7105
3f5e193b
NC		 7106struct hppa_unw_table_entry
7107 {
7108 struct absaddr start;
7109 struct absaddr end;
948f632f 7110 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7111 unsigned int Millicode:1; /* 1 */
7112 unsigned int Millicode_save_sr0:1; /* 2 */
7113 unsigned int Region_description:2; /* 3..4 */
7114 unsigned int reserved1:1; /* 5 */
7115 unsigned int Entry_SR:1; /* 6 */
7116 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7117 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7118 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7119 unsigned int Variable_Frame:1; /* 17 */
7120 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7121 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7122 unsigned int Stack_Overflow_Check:1; /* 20 */
7123 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7124 unsigned int Ada_Region:1; /* 22 */
7125 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7126 unsigned int cxx_try_catch:1; /* 24 */
7127 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7128 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7129 unsigned int Save_SP:1; /* 27 */
7130 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7131 unsigned int Save_MRP_in_frame:1; /* 29 */
7132 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7133 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7134
948f632f
DA		 7135 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7136 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7137 unsigned int Large_frame:1; /* 2 */
948f632f 7138 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7139 unsigned int reserved4:1; /* 4 */
7140 unsigned int Total_frame_size:27; /* 5..31 */
7141 };
7142
57346661 7143struct hppa_unw_aux_info
948f632f
DA		 7144{
7145 struct hppa_unw_table_entry * table; /* Unwind table. */
7146 unsigned long table_len; /* Length of unwind table. */
7147 bfd_vma seg_base; /* Starting address of segment. */
7148 Elf_Internal_Sym * symtab; /* The symbol table. */
7149 unsigned long nsyms; /* Number of symbols. */
7150 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7151 unsigned long nfuns; /* Number of entries in funtab. */
7152 char * strtab; /* The string table. */
7153 unsigned long strtab_size; /* Size of string table. */
7154};
57346661
AM		 7155
7156static void
2cf0635d 7157dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7158{
2cf0635d 7159 struct hppa_unw_table_entry * tp;
948f632f
DA		 7160 unsigned long j, nfuns;
7161
7162 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7163 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7164 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7165 aux->funtab[nfuns++] = aux->symtab[j];
7166 aux->nfuns = nfuns;
7167 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7168
57346661
AM		 7169 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7170 {
7171 bfd_vma offset;
2cf0635d 7172 const char * procname;
57346661 7173
948f632f 7174 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7175 aux->strtab_size, tp->start, &procname,
7176 &offset);
7177
7178 fputs ("\n<", stdout);
7179
7180 if (procname)
7181 {
7182 fputs (procname, stdout);
7183
7184 if (offset)
7185 printf ("+%lx", (unsigned long) offset);
7186 }
7187
7188 fputs (">: [", stdout);
7189 print_vma (tp->start.offset, PREFIX_HEX);
7190 fputc ('-', stdout);
7191 print_vma (tp->end.offset, PREFIX_HEX);
7192 printf ("]\n\t");
7193
18bd398b
NC		 7194#define PF(_m) if (tp->_m) printf (#_m " ");
7195#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7196 PF(Cannot_unwind);
7197 PF(Millicode);
7198 PF(Millicode_save_sr0);
18bd398b 7199 /* PV(Region_description); */
57346661
AM		 7200 PF(Entry_SR);
7201 PV(Entry_FR);
7202 PV(Entry_GR);
7203 PF(Args_stored);
7204 PF(Variable_Frame);
7205 PF(Separate_Package_Body);
7206 PF(Frame_Extension_Millicode);
7207 PF(Stack_Overflow_Check);
7208 PF(Two_Instruction_SP_Increment);
7209 PF(Ada_Region);
7210 PF(cxx_info);
7211 PF(cxx_try_catch);
7212 PF(sched_entry_seq);
7213 PF(Save_SP);
7214 PF(Save_RP);
7215 PF(Save_MRP_in_frame);
7216 PF(extn_ptr_defined);
7217 PF(Cleanup_defined);
7218 PF(MPE_XL_interrupt_marker);
7219 PF(HP_UX_interrupt_marker);
7220 PF(Large_frame);
7221 PF(Pseudo_SP_Set);
7222 PV(Total_frame_size);
7223#undef PF
7224#undef PV
7225 }
7226
18bd398b 7227 printf ("\n");
948f632f
DA		 7228
7229 free (aux->funtab);
57346661
AM		 7230}
7231
7232static int
2cf0635d
NC		 7233slurp_hppa_unwind_table (FILE * file,
7234 struct hppa_unw_aux_info * aux,
7235 Elf_Internal_Shdr * sec)
57346661 7236{
1c0751b2 7237 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7238 Elf_Internal_Phdr * seg;
7239 struct hppa_unw_table_entry * tep;
7240 Elf_Internal_Shdr * relsec;
7241 Elf_Internal_Rela * rela;
7242 Elf_Internal_Rela * rp;
7243 unsigned char * table;
7244 unsigned char * tp;
7245 Elf_Internal_Sym * sym;
7246 const char * relname;
57346661 7247
57346661
AM		 7248 /* First, find the starting address of the segment that includes
7249 this section. */
7250
7251 if (elf_header.e_phnum)
7252 {
7253 if (! get_program_headers (file))
7254 return 0;
7255
7256 for (seg = program_headers;
7257 seg < program_headers + elf_header.e_phnum;
7258 ++seg)
7259 {
7260 if (seg->p_type != PT_LOAD)
7261 continue;
7262
7263 if (sec->sh_addr >= seg->p_vaddr
7264 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7265 {
7266 aux->seg_base = seg->p_vaddr;
7267 break;
7268 }
7269 }
7270 }
7271
7272 /* Second, build the unwind table from the contents of the unwind
7273 section. */
7274 size = sec->sh_size;
3f5e193b
NC		 7275 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7276 _("unwind table"));
57346661
AM		 7277 if (!table)
7278 return 0;
7279
1c0751b2
DA		 7280 unw_ent_size = 16;
7281 nentries = size / unw_ent_size;
7282 size = unw_ent_size * nentries;
57346661 7283
3f5e193b
NC		 7284 tep = aux->table = (struct hppa_unw_table_entry *)
7285 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7286
1c0751b2 7287 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7288 {
7289 unsigned int tmp1, tmp2;
7290
7291 tep->start.section = SHN_UNDEF;
7292 tep->end.section = SHN_UNDEF;
7293
1c0751b2
DA		 7294 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7295 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7296 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7297 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7298
7299 tep->start.offset += aux->seg_base;
7300 tep->end.offset += aux->seg_base;
57346661
AM		 7301
7302 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7303 tep->Millicode = (tmp1 >> 30) & 0x1;
7304 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7305 tep->Region_description = (tmp1 >> 27) & 0x3;
7306 tep->reserved1 = (tmp1 >> 26) & 0x1;
7307 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7308 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7309 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7310 tep->Args_stored = (tmp1 >> 15) & 0x1;
7311 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7312 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7313 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7314 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7315 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7316 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7317 tep->cxx_info = (tmp1 >> 8) & 0x1;
7318 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7319 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7320 tep->reserved2 = (tmp1 >> 5) & 0x1;
7321 tep->Save_SP = (tmp1 >> 4) & 0x1;
7322 tep->Save_RP = (tmp1 >> 3) & 0x1;
7323 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7324 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7325 tep->Cleanup_defined = tmp1 & 0x1;
7326
7327 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7328 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7329 tep->Large_frame = (tmp2 >> 29) & 0x1;
7330 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7331 tep->reserved4 = (tmp2 >> 27) & 0x1;
7332 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7333 }
7334 free (table);
7335
7336 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7337 for (relsec = section_headers;
7338 relsec < section_headers + elf_header.e_shnum;
7339 ++relsec)
7340 {
7341 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7342 || relsec->sh_info >= elf_header.e_shnum
7343 || section_headers + relsec->sh_info != sec)
57346661
AM		 7344 continue;
7345
7346 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7347 & rela, & nrelas))
7348 return 0;
7349
7350 for (rp = rela; rp < rela + nrelas; ++rp)
7351 {
aca88567
NC		 7352 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7353 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7354
7355 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7356 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7357 {
7358 warn (_("Skipping unexpected relocation type %s\n"), relname);
7359 continue;
7360 }
7361
7362 i = rp->r_offset / unw_ent_size;
7363
89fac5e3 7364 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7365 {
7366 case 0:
7367 aux->table[i].start.section = sym->st_shndx;
1e456d54 7368 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7369 break;
7370 case 1:
7371 aux->table[i].end.section = sym->st_shndx;
1e456d54 7372 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7373 break;
7374 default:
7375 break;
7376 }
7377 }
7378
7379 free (rela);
7380 }
7381
1c0751b2 7382 aux->table_len = nentries;
57346661
AM		 7383
7384 return 1;
7385}
7386
1b31d05e 7387static void
2cf0635d 7388hppa_process_unwind (FILE * file)
57346661 7389{
57346661 7390 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7391 Elf_Internal_Shdr * unwsec = NULL;
7392 Elf_Internal_Shdr * strsec;
7393 Elf_Internal_Shdr * sec;
18bd398b 7394 unsigned long i;
57346661 7395
c256ffe7 7396 if (string_table == NULL)
1b31d05e
NC		 7397 return;
7398
7399 memset (& aux, 0, sizeof (aux));
57346661
AM		 7400
7401 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7402 {
c256ffe7 7403 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7404 && sec->sh_link < elf_header.e_shnum)
57346661 7405 {
ba5cdace 7406 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7407
4fbb74a6 7408 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7409 if (aux.strtab != NULL)
7410 {
7411 error (_("Multiple auxillary string tables encountered\n"));
7412 free (aux.strtab);
7413 }
3f5e193b
NC		 7414 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7415 1, strsec->sh_size,
7416 _("string table"));
c256ffe7 7417 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7418 }
18bd398b 7419 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7420 unwsec = sec;
7421 }
7422
7423 if (!unwsec)
7424 printf (_("\nThere are no unwind sections in this file.\n"));
7425
7426 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7427 {
18bd398b 7428 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7429 {
74e1a04b
NC		 7430 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7431 printable_section_name (sec),
57346661 7432 (unsigned long) sec->sh_offset,
89fac5e3 7433 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7434
7435 slurp_hppa_unwind_table (file, &aux, sec);
7436 if (aux.table_len > 0)
7437 dump_hppa_unwind (&aux);
7438
7439 if (aux.table)
7440 free ((char *) aux.table);
7441 aux.table = NULL;
7442 }
7443 }
7444
7445 if (aux.symtab)
7446 free (aux.symtab);
7447 if (aux.strtab)
7448 free ((char *) aux.strtab);
57346661
AM		 7449}
7450
0b6ae522
DJ		 7451struct arm_section
7452{
a734115a
NC		 7453 unsigned char * data; /* The unwind data. */
7454 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7455 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7456 unsigned long nrelas; /* The number of relocations. */
7457 unsigned int rel_type; /* REL or RELA ? */
7458 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7459};
7460
7461struct arm_unw_aux_info
7462{
a734115a
NC		 7463 FILE * file; /* The file containing the unwind sections. */
7464 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7465 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7466 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7467 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7468 char * strtab; /* The file's string table. */
7469 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7470};
7471
7472static const char *
7473arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7474 bfd_vma fn, struct absaddr addr)
7475{
7476 const char *procname;
7477 bfd_vma sym_offset;
7478
7479 if (addr.section == SHN_UNDEF)
7480 addr.offset = fn;
7481
948f632f 7482 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7483 aux->strtab_size, addr, &procname,
7484 &sym_offset);
7485
7486 print_vma (fn, PREFIX_HEX);
7487
7488 if (procname)
7489 {
7490 fputs (" <", stdout);
7491 fputs (procname, stdout);
7492
7493 if (sym_offset)
7494 printf ("+0x%lx", (unsigned long) sym_offset);
7495 fputc ('>', stdout);
7496 }
7497
7498 return procname;
7499}
7500
7501static void
7502arm_free_section (struct arm_section *arm_sec)
7503{
7504 if (arm_sec->data != NULL)
7505 free (arm_sec->data);
7506
7507 if (arm_sec->rela != NULL)
7508 free (arm_sec->rela);
7509}
7510
a734115a
NC		 7511/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7512 cached section and install SEC instead.
7513 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7514 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7515 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7516 relocation's offset in ADDR.
1b31d05e
NC		 7517 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7518 into the string table of the symbol associated with the reloc. If no
7519 reloc was applied store -1 there.
7520 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7521
7522static bfd_boolean
1b31d05e
NC		 7523get_unwind_section_word (struct arm_unw_aux_info * aux,
7524 struct arm_section * arm_sec,
7525 Elf_Internal_Shdr * sec,
7526 bfd_vma word_offset,
7527 unsigned int * wordp,
7528 struct absaddr * addr,
7529 bfd_vma * sym_name)
0b6ae522
DJ		 7530{
7531 Elf_Internal_Rela *rp;
7532 Elf_Internal_Sym *sym;
7533 const char * relname;
7534 unsigned int word;
7535 bfd_boolean wrapped;
7536
e0a31db1
NC		 7537 if (sec == NULL || arm_sec == NULL)
7538 return FALSE;
7539
0b6ae522
DJ		 7540 addr->section = SHN_UNDEF;
7541 addr->offset = 0;
7542
1b31d05e
NC		 7543 if (sym_name != NULL)
7544 *sym_name = (bfd_vma) -1;
7545
a734115a 7546 /* If necessary, update the section cache. */
0b6ae522
DJ		 7547 if (sec != arm_sec->sec)
7548 {
7549 Elf_Internal_Shdr *relsec;
7550
7551 arm_free_section (arm_sec);
7552
7553 arm_sec->sec = sec;
7554 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7555 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7556 arm_sec->rela = NULL;
7557 arm_sec->nrelas = 0;
7558
7559 for (relsec = section_headers;
7560 relsec < section_headers + elf_header.e_shnum;
7561 ++relsec)
7562 {
7563 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7564 || section_headers + relsec->sh_info != sec
7565 /* PR 15745: Check the section type as well. */
7566 || (relsec->sh_type != SHT_REL
7567 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7568 continue;
7569
a734115a 7570 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7571 if (relsec->sh_type == SHT_REL)
7572 {
7573 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7574 relsec->sh_size,
7575 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7576 return FALSE;
0b6ae522 7577 }
1ae40aa4 7578 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7579 {
7580 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7581 relsec->sh_size,
7582 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7583 return FALSE;
0b6ae522 7584 }
1ae40aa4 7585 break;
0b6ae522
DJ		 7586 }
7587
7588 arm_sec->next_rela = arm_sec->rela;
7589 }
7590
a734115a 7591 /* If there is no unwind data we can do nothing. */
0b6ae522 7592 if (arm_sec->data == NULL)
a734115a 7593 return FALSE;
0b6ae522 7594
e0a31db1 7595 /* If the offset is invalid then fail. */
1a915552
NC		 7596 if (word_offset > (sec->sh_size - 4)
7597 /* PR 18879 */
7598 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7599 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7600 return FALSE;
7601
a734115a 7602 /* Get the word at the required offset. */
0b6ae522
DJ		 7603 word = byte_get (arm_sec->data + word_offset, 4);
7604
0eff7165
NC		 7605 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7606 if (arm_sec->rela == NULL)
7607 {
7608 * wordp = word;
7609 return TRUE;
7610 }
7611
a734115a 7612 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7613 wrapped = FALSE;
7614 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7615 {
7616 bfd_vma prelval, offset;
7617
7618 if (rp->r_offset > word_offset && !wrapped)
7619 {
7620 rp = arm_sec->rela;
7621 wrapped = TRUE;
7622 }
7623 if (rp->r_offset > word_offset)
7624 break;
7625
7626 if (rp->r_offset & 3)
7627 {
7628 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7629 (unsigned long) rp->r_offset);
7630 continue;
7631 }
7632
7633 if (rp->r_offset < word_offset)
7634 continue;
7635
74e1a04b
NC		 7636 /* PR 17531: file: 027-161405-0.004 */
7637 if (aux->symtab == NULL)
7638 continue;
7639
0b6ae522
DJ		 7640 if (arm_sec->rel_type == SHT_REL)
7641 {
7642 offset = word & 0x7fffffff;
7643 if (offset & 0x40000000)
7644 offset |= ~ (bfd_vma) 0x7fffffff;
7645 }
a734115a 7646 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7647 offset = rp->r_addend;
a734115a 7648 else
74e1a04b
NC		 7649 {
7650 error (_("Unknown section relocation type %d encountered\n"),
7651 arm_sec->rel_type);
7652 break;
7653 }
0b6ae522 7654
071436c6
NC		 7655 /* PR 17531 file: 027-1241568-0.004. */
7656 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7657 {
7658 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7659 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7660 break;
7661 }
7662
7663 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7664 offset += sym->st_value;
7665 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7666
a734115a
NC		 7667 /* Check that we are processing the expected reloc type. */
7668 if (elf_header.e_machine == EM_ARM)
7669 {
7670 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7671 if (relname == NULL)
7672 {
7673 warn (_("Skipping unknown ARM relocation type: %d\n"),
7674 (int) ELF32_R_TYPE (rp->r_info));
7675 continue;
7676 }
a734115a
NC		 7677
7678 if (streq (relname, "R_ARM_NONE"))
7679 continue;
0b4362b0 7680
a734115a
NC		 7681 if (! streq (relname, "R_ARM_PREL31"))
7682 {
071436c6 7683 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7684 continue;
7685 }
7686 }
7687 else if (elf_header.e_machine == EM_TI_C6000)
7688 {
7689 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7690 if (relname == NULL)
7691 {
7692 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7693 (int) ELF32_R_TYPE (rp->r_info));
7694 continue;
7695 }
0b4362b0 7696
a734115a
NC		 7697 if (streq (relname, "R_C6000_NONE"))
7698 continue;
7699
7700 if (! streq (relname, "R_C6000_PREL31"))
7701 {
071436c6 7702 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7703 continue;
7704 }
7705
7706 prelval >>= 1;
7707 }
7708 else
74e1a04b
NC		 7709 {
7710 /* This function currently only supports ARM and TI unwinders. */
7711 warn (_("Only TI and ARM unwinders are currently supported\n"));
7712 break;
7713 }
fa197c1c 7714
0b6ae522
DJ		 7715 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7716 addr->section = sym->st_shndx;
7717 addr->offset = offset;
74e1a04b 7718
1b31d05e
NC		 7719 if (sym_name)
7720 * sym_name = sym->st_name;
0b6ae522
DJ		 7721 break;
7722 }
7723
7724 *wordp = word;
7725 arm_sec->next_rela = rp;
7726
a734115a 7727 return TRUE;
0b6ae522
DJ		 7728}
7729
a734115a
NC		 7730static const char *tic6x_unwind_regnames[16] =
7731{
0b4362b0
RM		 7732 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7733 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7734 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7735};
fa197c1c 7736
0b6ae522 7737static void
fa197c1c 7738decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7739{
fa197c1c
PB		 7740 int i;
7741
7742 for (i = 12; mask; mask >>= 1, i--)
7743 {
7744 if (mask & 1)
7745 {
7746 fputs (tic6x_unwind_regnames[i], stdout);
7747 if (mask > 1)
7748 fputs (", ", stdout);
7749 }
7750 }
7751}
0b6ae522
DJ		 7752
7753#define ADVANCE \
7754 if (remaining == 0 && more_words) \
7755 { \
7756 data_offset += 4; \
1b31d05e
NC		 7757 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7758 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7759 return; \
7760 remaining = 4; \
7761 more_words--; \
7762 } \
7763
7764#define GET_OP(OP) \
7765 ADVANCE; \
7766 if (remaining) \
7767 { \
7768 remaining--; \
7769 (OP) = word >> 24; \
7770 word <<= 8; \
7771 } \
7772 else \
7773 { \
2b692964 7774 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7775 return; \
7776 } \
cc5914eb 7777 printf ("0x%02x ", OP)
0b6ae522 7778
fa197c1c 7779static void
948f632f
DA		 7780decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7781 unsigned int word,
7782 unsigned int remaining,
7783 unsigned int more_words,
7784 bfd_vma data_offset,
7785 Elf_Internal_Shdr * data_sec,
7786 struct arm_section * data_arm_sec)
fa197c1c
PB		 7787{
7788 struct absaddr addr;
0b6ae522
DJ		 7789
7790 /* Decode the unwinding instructions. */
7791 while (1)
7792 {
7793 unsigned int op, op2;
7794
7795 ADVANCE;
7796 if (remaining == 0)
7797 break;
7798 remaining--;
7799 op = word >> 24;
7800 word <<= 8;
7801
cc5914eb 7802 printf (" 0x%02x ", op);
0b6ae522
DJ		 7803
7804 if ((op & 0xc0) == 0x00)
7805 {
7806 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7807
cc5914eb 7808 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7809 }
7810 else if ((op & 0xc0) == 0x40)
7811 {
7812 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7813
cc5914eb 7814 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7815 }
7816 else if ((op & 0xf0) == 0x80)
7817 {
7818 GET_OP (op2);
7819 if (op == 0x80 && op2 == 0)
7820 printf (_("Refuse to unwind"));
7821 else
7822 {
7823 unsigned int mask = ((op & 0x0f) << 8) | op2;
7824 int first = 1;
7825 int i;
2b692964 7826
0b6ae522
DJ		 7827 printf ("pop {");
7828 for (i = 0; i < 12; i++)
7829 if (mask & (1 << i))
7830 {
7831 if (first)
7832 first = 0;
7833 else
7834 printf (", ");
7835 printf ("r%d", 4 + i);
7836 }
7837 printf ("}");
7838 }
7839 }
7840 else if ((op & 0xf0) == 0x90)
7841 {
7842 if (op == 0x9d || op == 0x9f)
7843 printf (_(" [Reserved]"));
7844 else
cc5914eb 7845 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7846 }
7847 else if ((op & 0xf0) == 0xa0)
7848 {
7849 int end = 4 + (op & 0x07);
7850 int first = 1;
7851 int i;
61865e30 7852
0b6ae522
DJ		 7853 printf (" pop {");
7854 for (i = 4; i <= end; i++)
7855 {
7856 if (first)
7857 first = 0;
7858 else
7859 printf (", ");
7860 printf ("r%d", i);
7861 }
7862 if (op & 0x08)
7863 {
1b31d05e 7864 if (!first)
0b6ae522
DJ		 7865 printf (", ");
7866 printf ("r14");
7867 }
7868 printf ("}");
7869 }
7870 else if (op == 0xb0)
7871 printf (_(" finish"));
7872 else if (op == 0xb1)
7873 {
7874 GET_OP (op2);
7875 if (op2 == 0 || (op2 & 0xf0) != 0)
7876 printf (_("[Spare]"));
7877 else
7878 {
7879 unsigned int mask = op2 & 0x0f;
7880 int first = 1;
7881 int i;
61865e30 7882
0b6ae522
DJ		 7883 printf ("pop {");
7884 for (i = 0; i < 12; i++)
7885 if (mask & (1 << i))
7886 {
7887 if (first)
7888 first = 0;
7889 else
7890 printf (", ");
7891 printf ("r%d", i);
7892 }
7893 printf ("}");
7894 }
7895 }
7896 else if (op == 0xb2)
7897 {
b115cf96 7898 unsigned char buf[9];
0b6ae522
DJ		 7899 unsigned int i, len;
7900 unsigned long offset;
61865e30 7901
b115cf96 7902 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7903 {
7904 GET_OP (buf[i]);
7905 if ((buf[i] & 0x80) == 0)
7906 break;
7907 }
4082ef84
NC		 7908 if (i == sizeof (buf))
7909 printf (_("corrupt change to vsp"));
7910 else
7911 {
7912 offset = read_uleb128 (buf, &len, buf + i + 1);
7913 assert (len == i + 1);
7914 offset = offset * 4 + 0x204;
7915 printf ("vsp = vsp + %ld", offset);
7916 }
0b6ae522 7917 }
61865e30 7918 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7919 {
61865e30
NC		 7920 unsigned int first, last;
7921
7922 GET_OP (op2);
7923 first = op2 >> 4;
7924 last = op2 & 0x0f;
7925 if (op == 0xc8)
7926 first = first + 16;
7927 printf ("pop {D%d", first);
7928 if (last)
7929 printf ("-D%d", first + last);
7930 printf ("}");
7931 }
7932 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7933 {
7934 unsigned int count = op & 0x07;
7935
7936 printf ("pop {D8");
7937 if (count)
7938 printf ("-D%d", 8 + count);
7939 printf ("}");
7940 }
7941 else if (op >= 0xc0 && op <= 0xc5)
7942 {
7943 unsigned int count = op & 0x07;
7944
7945 printf (" pop {wR10");
7946 if (count)
7947 printf ("-wR%d", 10 + count);
7948 printf ("}");
7949 }
7950 else if (op == 0xc6)
7951 {
7952 unsigned int first, last;
7953
7954 GET_OP (op2);
7955 first = op2 >> 4;
7956 last = op2 & 0x0f;
7957 printf ("pop {wR%d", first);
7958 if (last)
7959 printf ("-wR%d", first + last);
7960 printf ("}");
7961 }
7962 else if (op == 0xc7)
7963 {
7964 GET_OP (op2);
7965 if (op2 == 0 || (op2 & 0xf0) != 0)
7966 printf (_("[Spare]"));
0b6ae522
DJ		 7967 else
7968 {
61865e30
NC		 7969 unsigned int mask = op2 & 0x0f;
7970 int first = 1;
7971 int i;
7972
7973 printf ("pop {");
7974 for (i = 0; i < 4; i++)
7975 if (mask & (1 << i))
7976 {
7977 if (first)
7978 first = 0;
7979 else
7980 printf (", ");
7981 printf ("wCGR%d", i);
7982 }
7983 printf ("}");
0b6ae522
DJ		 7984 }
7985 }
61865e30
NC		 7986 else
7987 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7988 printf ("\n");
7989 }
fa197c1c
PB		 7990}
7991
7992static void
948f632f
DA		 7993decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7994 unsigned int word,
7995 unsigned int remaining,
7996 unsigned int more_words,
7997 bfd_vma data_offset,
7998 Elf_Internal_Shdr * data_sec,
7999 struct arm_section * data_arm_sec)
fa197c1c
PB		 8000{
8001 struct absaddr addr;
8002
8003 /* Decode the unwinding instructions. */
8004 while (1)
8005 {
8006 unsigned int op, op2;
8007
8008 ADVANCE;
8009 if (remaining == 0)
8010 break;
8011 remaining--;
8012 op = word >> 24;
8013 word <<= 8;
8014
9cf03b7e 8015 printf (" 0x%02x ", op);
fa197c1c
PB		 8016
8017 if ((op & 0xc0) == 0x00)
8018 {
8019 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8020 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8021 }
8022 else if ((op & 0xc0) == 0x80)
8023 {
8024 GET_OP (op2);
8025 if (op == 0x80 && op2 == 0)
8026 printf (_("Refuse to unwind"));
8027 else
8028 {
8029 unsigned int mask = ((op & 0x1f) << 8) | op2;
8030 if (op & 0x20)
8031 printf ("pop compact {");
8032 else
8033 printf ("pop {");
8034
8035 decode_tic6x_unwind_regmask (mask);
8036 printf("}");
8037 }
8038 }
8039 else if ((op & 0xf0) == 0xc0)
8040 {
8041 unsigned int reg;
8042 unsigned int nregs;
8043 unsigned int i;
8044 const char *name;
a734115a
NC		 8045 struct
8046 {
fa197c1c
PB		 8047 unsigned int offset;
8048 unsigned int reg;
8049 } regpos[16];
8050
8051 /* Scan entire instruction first so that GET_OP output is not
8052 interleaved with disassembly. */
8053 nregs = 0;
8054 for (i = 0; nregs < (op & 0xf); i++)
8055 {
8056 GET_OP (op2);
8057 reg = op2 >> 4;
8058 if (reg != 0xf)
8059 {
8060 regpos[nregs].offset = i * 2;
8061 regpos[nregs].reg = reg;
8062 nregs++;
8063 }
8064
8065 reg = op2 & 0xf;
8066 if (reg != 0xf)
8067 {
8068 regpos[nregs].offset = i * 2 + 1;
8069 regpos[nregs].reg = reg;
8070 nregs++;
8071 }
8072 }
8073
8074 printf (_("pop frame {"));
8075 reg = nregs - 1;
8076 for (i = i * 2; i > 0; i--)
8077 {
8078 if (regpos[reg].offset == i - 1)
8079 {
8080 name = tic6x_unwind_regnames[regpos[reg].reg];
8081 if (reg > 0)
8082 reg--;
8083 }
8084 else
8085 name = _("[pad]");
8086
8087 fputs (name, stdout);
8088 if (i > 1)
8089 printf (", ");
8090 }
8091
8092 printf ("}");
8093 }
8094 else if (op == 0xd0)
8095 printf (" MOV FP, SP");
8096 else if (op == 0xd1)
8097 printf (" __c6xabi_pop_rts");
8098 else if (op == 0xd2)
8099 {
8100 unsigned char buf[9];
8101 unsigned int i, len;
8102 unsigned long offset;
a734115a 8103
fa197c1c
PB		 8104 for (i = 0; i < sizeof (buf); i++)
8105 {
8106 GET_OP (buf[i]);
8107 if ((buf[i] & 0x80) == 0)
8108 break;
8109 }
0eff7165
NC		 8110 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8111 if (i == sizeof (buf))
8112 {
8113 printf ("<corrupt sp adjust>\n");
8114 warn (_("Corrupt stack pointer adjustment detected\n"));
8115 return;
8116 }
948f632f 8117
f6f0e17b 8118 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8119 assert (len == i + 1);
8120 offset = offset * 8 + 0x408;
8121 printf (_("sp = sp + %ld"), offset);
8122 }
8123 else if ((op & 0xf0) == 0xe0)
8124 {
8125 if ((op & 0x0f) == 7)
8126 printf (" RETURN");
8127 else
8128 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8129 }
8130 else
8131 {
8132 printf (_(" [unsupported opcode]"));
8133 }
8134 putchar ('\n');
8135 }
8136}
8137
8138static bfd_vma
a734115a 8139arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8140{
8141 bfd_vma offset;
8142
8143 offset = word & 0x7fffffff;
8144 if (offset & 0x40000000)
8145 offset |= ~ (bfd_vma) 0x7fffffff;
8146
8147 if (elf_header.e_machine == EM_TI_C6000)
8148 offset <<= 1;
8149
8150 return offset + where;
8151}
8152
8153static void
1b31d05e
NC		 8154decode_arm_unwind (struct arm_unw_aux_info * aux,
8155 unsigned int word,
8156 unsigned int remaining,
8157 bfd_vma data_offset,
8158 Elf_Internal_Shdr * data_sec,
8159 struct arm_section * data_arm_sec)
fa197c1c
PB		 8160{
8161 int per_index;
8162 unsigned int more_words = 0;
37e14bc3 8163 struct absaddr addr;
1b31d05e 8164 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8165
8166 if (remaining == 0)
8167 {
1b31d05e
NC		 8168 /* Fetch the first word.
8169 Note - when decoding an object file the address extracted
8170 here will always be 0. So we also pass in the sym_name
8171 parameter so that we can find the symbol associated with
8172 the personality routine. */
8173 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8174 & word, & addr, & sym_name))
fa197c1c 8175 return;
1b31d05e 8176
fa197c1c
PB		 8177 remaining = 4;
8178 }
8179
8180 if ((word & 0x80000000) == 0)
8181 {
8182 /* Expand prel31 for personality routine. */
8183 bfd_vma fn;
8184 const char *procname;
8185
a734115a 8186 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8187 printf (_(" Personality routine: "));
1b31d05e
NC		 8188 if (fn == 0
8189 && addr.section == SHN_UNDEF && addr.offset == 0
8190 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8191 {
8192 procname = aux->strtab + sym_name;
8193 print_vma (fn, PREFIX_HEX);
8194 if (procname)
8195 {
8196 fputs (" <", stdout);
8197 fputs (procname, stdout);
8198 fputc ('>', stdout);
8199 }
8200 }
8201 else
8202 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8203 fputc ('\n', stdout);
8204
8205 /* The GCC personality routines use the standard compact
8206 encoding, starting with one byte giving the number of
8207 words. */
8208 if (procname != NULL
8209 && (const_strneq (procname, "__gcc_personality_v0")
8210 || const_strneq (procname, "__gxx_personality_v0")
8211 || const_strneq (procname, "__gcj_personality_v0")
8212 || const_strneq (procname, "__gnu_objc_personality_v0")))
8213 {
8214 remaining = 0;
8215 more_words = 1;
8216 ADVANCE;
8217 if (!remaining)
8218 {
8219 printf (_(" [Truncated data]\n"));
8220 return;
8221 }
8222 more_words = word >> 24;
8223 word <<= 8;
8224 remaining--;
8225 per_index = -1;
8226 }
8227 else
8228 return;
8229 }
8230 else
8231 {
1b31d05e 8232 /* ARM EHABI Section 6.3:
0b4362b0 8233
1b31d05e 8234 An exception-handling table entry for the compact model looks like:
0b4362b0 8235
1b31d05e
NC		 8236 31 30-28 27-24 23-0
8237 -- ----- ----- ----
8238 1 0 index Data for personalityRoutine[index] */
8239
8240 if (elf_header.e_machine == EM_ARM
8241 && (word & 0x70000000))
83c257ca 8242 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8243
fa197c1c 8244 per_index = (word >> 24) & 0x7f;
1b31d05e 8245 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8246 if (per_index == 0)
8247 {
8248 more_words = 0;
8249 word <<= 8;
8250 remaining--;
8251 }
8252 else if (per_index < 3)
8253 {
8254 more_words = (word >> 16) & 0xff;
8255 word <<= 16;
8256 remaining -= 2;
8257 }
8258 }
8259
8260 switch (elf_header.e_machine)
8261 {
8262 case EM_ARM:
8263 if (per_index < 3)
8264 {
8265 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8266 data_offset, data_sec, data_arm_sec);
8267 }
8268 else
1b31d05e
NC		 8269 {
8270 warn (_("Unknown ARM compact model index encountered\n"));
8271 printf (_(" [reserved]\n"));
8272 }
fa197c1c
PB		 8273 break;
8274
8275 case EM_TI_C6000:
8276 if (per_index < 3)
8277 {
8278 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8279 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8280 }
8281 else if (per_index < 5)
8282 {
8283 if (((word >> 17) & 0x7f) == 0x7f)
8284 printf (_(" Restore stack from frame pointer\n"));
8285 else
8286 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8287 printf (_(" Registers restored: "));
8288 if (per_index == 4)
8289 printf (" (compact) ");
8290 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8291 putchar ('\n');
8292 printf (_(" Return register: %s\n"),
8293 tic6x_unwind_regnames[word & 0xf]);
8294 }
8295 else
1b31d05e 8296 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8297 break;
8298
8299 default:
74e1a04b 8300 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8301 elf_header.e_machine);
fa197c1c 8302 }
0b6ae522
DJ		 8303
8304 /* Decode the descriptors. Not implemented. */
8305}
8306
8307static void
8308dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8309{
8310 struct arm_section exidx_arm_sec, extab_arm_sec;
8311 unsigned int i, exidx_len;
948f632f 8312 unsigned long j, nfuns;
0b6ae522
DJ		 8313
8314 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8315 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8316 exidx_len = exidx_sec->sh_size / 8;
8317
948f632f
DA		 8318 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8319 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8320 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8321 aux->funtab[nfuns++] = aux->symtab[j];
8322 aux->nfuns = nfuns;
8323 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8324
0b6ae522
DJ		 8325 for (i = 0; i < exidx_len; i++)
8326 {
8327 unsigned int exidx_fn, exidx_entry;
8328 struct absaddr fn_addr, entry_addr;
8329 bfd_vma fn;
8330
8331 fputc ('\n', stdout);
8332
1b31d05e
NC		 8333 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8334 8 * i, & exidx_fn, & fn_addr, NULL)
8335 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8336 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8337 {
948f632f 8338 free (aux->funtab);
1b31d05e
NC		 8339 arm_free_section (& exidx_arm_sec);
8340 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8341 return;
8342 }
8343
83c257ca
NC		 8344 /* ARM EHABI, Section 5:
8345 An index table entry consists of 2 words.
8346 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8347 if (exidx_fn & 0x80000000)
8348 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8349
a734115a 8350 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8351
a734115a 8352 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8353 fputs (": ", stdout);
8354
8355 if (exidx_entry == 1)
8356 {
8357 print_vma (exidx_entry, PREFIX_HEX);
8358 fputs (" [cantunwind]\n", stdout);
8359 }
8360 else if (exidx_entry & 0x80000000)
8361 {
8362 print_vma (exidx_entry, PREFIX_HEX);
8363 fputc ('\n', stdout);
8364 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8365 }
8366 else
8367 {
8f73510c 8368 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8369 Elf_Internal_Shdr *table_sec;
8370
8371 fputs ("@", stdout);
a734115a 8372 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8373 print_vma (table, PREFIX_HEX);
8374 printf ("\n");
8375
8376 /* Locate the matching .ARM.extab. */
8377 if (entry_addr.section != SHN_UNDEF
8378 && entry_addr.section < elf_header.e_shnum)
8379 {
8380 table_sec = section_headers + entry_addr.section;
8381 table_offset = entry_addr.offset;
1a915552
NC		 8382 /* PR 18879 */
8383 if (table_offset > table_sec->sh_size
8384 || ((bfd_signed_vma) table_offset) < 0)
8385 {
8386 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8387 (unsigned long) table_offset,
8388 printable_section_name (table_sec));
8389 continue;
8390 }
0b6ae522
DJ		 8391 }
8392 else
8393 {
8394 table_sec = find_section_by_address (table);
8395 if (table_sec != NULL)
8396 table_offset = table - table_sec->sh_addr;
8397 }
8398 if (table_sec == NULL)
8399 {
8400 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8401 (unsigned long) table);
8402 continue;
8403 }
8404 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8405 &extab_arm_sec);
8406 }
8407 }
8408
8409 printf ("\n");
8410
948f632f 8411 free (aux->funtab);
0b6ae522
DJ		 8412 arm_free_section (&exidx_arm_sec);
8413 arm_free_section (&extab_arm_sec);
8414}
8415
fa197c1c 8416/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8417
8418static void
0b6ae522
DJ		 8419arm_process_unwind (FILE *file)
8420{
8421 struct arm_unw_aux_info aux;
8422 Elf_Internal_Shdr *unwsec = NULL;
8423 Elf_Internal_Shdr *strsec;
8424 Elf_Internal_Shdr *sec;
8425 unsigned long i;
fa197c1c 8426 unsigned int sec_type;
0b6ae522 8427
fa197c1c
PB		 8428 switch (elf_header.e_machine)
8429 {
8430 case EM_ARM:
8431 sec_type = SHT_ARM_EXIDX;
8432 break;
8433
8434 case EM_TI_C6000:
8435 sec_type = SHT_C6000_UNWIND;
8436 break;
8437
0b4362b0 8438 default:
74e1a04b 8439 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8440 elf_header.e_machine);
8441 return;
fa197c1c
PB		 8442 }
8443
0b6ae522 8444 if (string_table == NULL)
1b31d05e
NC		 8445 return;
8446
8447 memset (& aux, 0, sizeof (aux));
8448 aux.file = file;
0b6ae522
DJ		 8449
8450 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8451 {
8452 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8453 {
ba5cdace 8454 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8455
8456 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8457
8458 /* PR binutils/17531 file: 011-12666-0.004. */
8459 if (aux.strtab != NULL)
8460 {
4082ef84 8461 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8462 free (aux.strtab);
8463 }
0b6ae522
DJ		 8464 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8465 1, strsec->sh_size, _("string table"));
8466 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8467 }
fa197c1c 8468 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8469 unwsec = sec;
8470 }
8471
1b31d05e 8472 if (unwsec == NULL)
0b6ae522 8473 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8474 else
8475 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8476 {
8477 if (sec->sh_type == sec_type)
8478 {
8479 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8480 printable_section_name (sec),
1b31d05e
NC		 8481 (unsigned long) sec->sh_offset,
8482 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8483
1b31d05e
NC		 8484 dump_arm_unwind (&aux, sec);
8485 }
8486 }
0b6ae522
DJ		 8487
8488 if (aux.symtab)
8489 free (aux.symtab);
8490 if (aux.strtab)
8491 free ((char *) aux.strtab);
0b6ae522
DJ		 8492}
8493
1b31d05e 8494static void
2cf0635d 8495process_unwind (FILE * file)
57346661 8496{
2cf0635d
NC		 8497 struct unwind_handler
8498 {
57346661 8499 int machtype;
1b31d05e 8500 void (* handler)(FILE *);
2cf0635d
NC		 8501 } handlers[] =
8502 {
0b6ae522 8503 { EM_ARM, arm_process_unwind },
57346661
AM		 8504 { EM_IA_64, ia64_process_unwind },
8505 { EM_PARISC, hppa_process_unwind },
fa197c1c 8506 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8507 { 0, 0 }
8508 };
8509 int i;
8510
8511 if (!do_unwind)
1b31d05e 8512 return;
57346661
AM		 8513
8514 for (i = 0; handlers[i].handler != NULL; i++)
8515 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8516 {
8517 handlers[i].handler (file);
8518 return;
8519 }
57346661 8520
1b31d05e
NC		 8521 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8522 get_machine_name (elf_header.e_machine));
57346661
AM		 8523}
8524
252b5132 8525static void
2cf0635d 8526dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8527{
8528 switch (entry->d_tag)
8529 {
8530 case DT_MIPS_FLAGS:
8531 if (entry->d_un.d_val == 0)
4b68bca3 8532 printf (_("NONE"));
252b5132
RH		 8533 else
8534 {
8535 static const char * opts[] =
8536 {
8537 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8538 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8539 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8540 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8541 "RLD_ORDER_SAFE"
8542 };
8543 unsigned int cnt;
8544 int first = 1;
2b692964 8545
60bca95a 8546 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8547 if (entry->d_un.d_val & (1 << cnt))
8548 {
8549 printf ("%s%s", first ? "" : " ", opts[cnt]);
8550 first = 0;
8551 }
252b5132
RH		 8552 }
8553 break;
103f02d3 8554
252b5132 8555 case DT_MIPS_IVERSION:
d79b3d50 8556 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8557 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8558 else
76ca31c0
NC		 8559 {
8560 char buf[40];
8561 sprintf_vma (buf, entry->d_un.d_ptr);
8562 /* Note: coded this way so that there is a single string for translation. */
8563 printf (_("<corrupt: %s>"), buf);
8564 }
252b5132 8565 break;
103f02d3 8566
252b5132
RH		 8567 case DT_MIPS_TIME_STAMP:
8568 {
8569 char timebuf[20];
2cf0635d 8570 struct tm * tmp;
91d6fa6a 8571 time_t atime = entry->d_un.d_val;
82b1b41b 8572
91d6fa6a 8573 tmp = gmtime (&atime);
82b1b41b
NC		 8574 /* PR 17531: file: 6accc532. */
8575 if (tmp == NULL)
8576 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8577 else
8578 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8579 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8580 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8581 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8582 }
8583 break;
103f02d3 8584
252b5132
RH		 8585 case DT_MIPS_RLD_VERSION:
8586 case DT_MIPS_LOCAL_GOTNO:
8587 case DT_MIPS_CONFLICTNO:
8588 case DT_MIPS_LIBLISTNO:
8589 case DT_MIPS_SYMTABNO:
8590 case DT_MIPS_UNREFEXTNO:
8591 case DT_MIPS_HIPAGENO:
8592 case DT_MIPS_DELTA_CLASS_NO:
8593 case DT_MIPS_DELTA_INSTANCE_NO:
8594 case DT_MIPS_DELTA_RELOC_NO:
8595 case DT_MIPS_DELTA_SYM_NO:
8596 case DT_MIPS_DELTA_CLASSSYM_NO:
8597 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8598 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8599 break;
103f02d3
UD		 8600
8601 default:
4b68bca3 8602 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8603 }
4b68bca3 8604 putchar ('\n');
103f02d3
UD		 8605}
8606
103f02d3 8607static void
2cf0635d 8608dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8609{
8610 switch (entry->d_tag)
8611 {
8612 case DT_HP_DLD_FLAGS:
8613 {
8614 static struct
8615 {
8616 long int bit;
2cf0635d 8617 const char * str;
5e220199
NC		 8618 }
8619 flags[] =
8620 {
8621 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8622 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8623 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8624 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8625 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8626 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8627 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8628 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8629 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8630 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8631 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8632 { DT_HP_GST, "HP_GST" },
8633 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8634 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8635 { DT_HP_NODELETE, "HP_NODELETE" },
8636 { DT_HP_GROUP, "HP_GROUP" },
8637 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8638 };
103f02d3 8639 int first = 1;
5e220199 8640 size_t cnt;
f7a99963 8641 bfd_vma val = entry->d_un.d_val;
103f02d3 8642
60bca95a 8643 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8644 if (val & flags[cnt].bit)
30800947
NC		 8645 {
8646 if (! first)
8647 putchar (' ');
8648 fputs (flags[cnt].str, stdout);
8649 first = 0;
8650 val ^= flags[cnt].bit;
8651 }
76da6bbe 8652
103f02d3 8653 if (val != 0 || first)
f7a99963
NC		 8654 {
8655 if (! first)
8656 putchar (' ');
8657 print_vma (val, HEX);
8658 }
103f02d3
UD		 8659 }
8660 break;
76da6bbe 8661
252b5132 8662 default:
f7a99963
NC		 8663 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8664 break;
252b5132 8665 }
35b1837e 8666 putchar ('\n');
252b5132
RH		 8667}
8668
28f997cf
TG		 8669#ifdef BFD64
8670
8671/* VMS vs Unix time offset and factor. */
8672
8673#define VMS_EPOCH_OFFSET 35067168000000000LL
8674#define VMS_GRANULARITY_FACTOR 10000000
8675
8676/* Display a VMS time in a human readable format. */
8677
8678static void
8679print_vms_time (bfd_int64_t vmstime)
8680{
8681 struct tm *tm;
8682 time_t unxtime;
8683
8684 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8685 tm = gmtime (&unxtime);
8686 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8687 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8688 tm->tm_hour, tm->tm_min, tm->tm_sec);
8689}
8690#endif /* BFD64 */
8691
ecc51f48 8692static void
2cf0635d 8693dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8694{
8695 switch (entry->d_tag)
8696 {
0de14b54 8697 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8698 /* First 3 slots reserved. */
ecc51f48
NC		 8699 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8700 printf (" -- ");
8701 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8702 break;
8703
28f997cf
TG		 8704 case DT_IA_64_VMS_LINKTIME:
8705#ifdef BFD64
8706 print_vms_time (entry->d_un.d_val);
8707#endif
8708 break;
8709
8710 case DT_IA_64_VMS_LNKFLAGS:
8711 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8712 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8713 printf (" CALL_DEBUG");
8714 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8715 printf (" NOP0BUFS");
8716 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8717 printf (" P0IMAGE");
8718 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8719 printf (" MKTHREADS");
8720 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8721 printf (" UPCALLS");
8722 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8723 printf (" IMGSTA");
8724 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8725 printf (" INITIALIZE");
8726 if (entry->d_un.d_val & VMS_LF_MAIN)
8727 printf (" MAIN");
8728 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8729 printf (" EXE_INIT");
8730 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8731 printf (" TBK_IN_IMG");
8732 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8733 printf (" DBG_IN_IMG");
8734 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8735 printf (" TBK_IN_DSF");
8736 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8737 printf (" DBG_IN_DSF");
8738 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8739 printf (" SIGNATURES");
8740 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8741 printf (" REL_SEG_OFF");
8742 break;
8743
bdf4d63a
JJ		 8744 default:
8745 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8746 break;
ecc51f48 8747 }
bdf4d63a 8748 putchar ('\n');
ecc51f48
NC		 8749}
8750
252b5132 8751static int
2cf0635d 8752get_32bit_dynamic_section (FILE * file)
252b5132 8753{
2cf0635d
NC		 8754 Elf32_External_Dyn * edyn;
8755 Elf32_External_Dyn * ext;
8756 Elf_Internal_Dyn * entry;
103f02d3 8757
3f5e193b
NC		 8758 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8759 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8760 if (!edyn)
8761 return 0;
103f02d3 8762
071436c6
NC		 8763 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8764 might not have the luxury of section headers. Look for the DT_NULL
8765 terminator to determine the number of entries. */
ba2685cc 8766 for (ext = edyn, dynamic_nent = 0;
53c3012c 8767 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8768 ext++)
8769 {
8770 dynamic_nent++;
8771 if (BYTE_GET (ext->d_tag) == DT_NULL)
8772 break;
8773 }
252b5132 8774
3f5e193b
NC		 8775 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8776 sizeof (* entry));
b2d38a17 8777 if (dynamic_section == NULL)
252b5132 8778 {
8b73c356
NC		 8779 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8780 (unsigned long) dynamic_nent);
9ea033b2
NC		 8781 free (edyn);
8782 return 0;
8783 }
252b5132 8784
fb514b26 8785 for (ext = edyn, entry = dynamic_section;
ba2685cc 8786 entry < dynamic_section + dynamic_nent;
fb514b26 8787 ext++, entry++)
9ea033b2 8788 {
fb514b26
AM		 8789 entry->d_tag = BYTE_GET (ext->d_tag);
8790 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8791 }
8792
9ea033b2
NC		 8793 free (edyn);
8794
8795 return 1;
8796}
8797
8798static int
2cf0635d 8799get_64bit_dynamic_section (FILE * file)
9ea033b2 8800{
2cf0635d
NC		 8801 Elf64_External_Dyn * edyn;
8802 Elf64_External_Dyn * ext;
8803 Elf_Internal_Dyn * entry;
103f02d3 8804
071436c6 8805 /* Read in the data. */
3f5e193b
NC		 8806 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8807 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8808 if (!edyn)
8809 return 0;
103f02d3 8810
071436c6
NC		 8811 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8812 might not have the luxury of section headers. Look for the DT_NULL
8813 terminator to determine the number of entries. */
ba2685cc 8814 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8815 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8816 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8817 ext++)
8818 {
8819 dynamic_nent++;
66543521 8820 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8821 break;
8822 }
252b5132 8823
3f5e193b
NC		 8824 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8825 sizeof (* entry));
b2d38a17 8826 if (dynamic_section == NULL)
252b5132 8827 {
8b73c356
NC		 8828 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8829 (unsigned long) dynamic_nent);
252b5132
RH		 8830 free (edyn);
8831 return 0;
8832 }
8833
071436c6 8834 /* Convert from external to internal formats. */
fb514b26 8835 for (ext = edyn, entry = dynamic_section;
ba2685cc 8836 entry < dynamic_section + dynamic_nent;
fb514b26 8837 ext++, entry++)
252b5132 8838 {
66543521
AM		 8839 entry->d_tag = BYTE_GET (ext->d_tag);
8840 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8841 }
8842
8843 free (edyn);
8844
9ea033b2
NC		 8845 return 1;
8846}
8847
e9e44622
JJ		 8848static void
8849print_dynamic_flags (bfd_vma flags)
d1133906 8850{
e9e44622 8851 int first = 1;
13ae64f3 8852
d1133906
NC		 8853 while (flags)
8854 {
8855 bfd_vma flag;
8856
8857 flag = flags & - flags;
8858 flags &= ~ flag;
8859
e9e44622
JJ		 8860 if (first)
8861 first = 0;
8862 else
8863 putc (' ', stdout);
13ae64f3 8864
d1133906
NC		 8865 switch (flag)
8866 {
e9e44622
JJ		 8867 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8868 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8869 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8870 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8871 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8872 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8873 }
8874 }
e9e44622 8875 puts ("");
d1133906
NC		 8876}
8877
b2d38a17
NC		 8878/* Parse and display the contents of the dynamic section. */
8879
9ea033b2 8880static int
2cf0635d 8881process_dynamic_section (FILE * file)
9ea033b2 8882{
2cf0635d 8883 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8884
8885 if (dynamic_size == 0)
8886 {
8887 if (do_dynamic)
b2d38a17 8888 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8889
8890 return 1;
8891 }
8892
8893 if (is_32bit_elf)
8894 {
b2d38a17 8895 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8896 return 0;
8897 }
b2d38a17 8898 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8899 return 0;
8900
252b5132
RH		 8901 /* Find the appropriate symbol table. */
8902 if (dynamic_symbols == NULL)
8903 {
86dba8ee
AM		 8904 for (entry = dynamic_section;
8905 entry < dynamic_section + dynamic_nent;
8906 ++entry)
252b5132 8907 {
c8286bd1 8908 Elf_Internal_Shdr section;
252b5132
RH		 8909
8910 if (entry->d_tag != DT_SYMTAB)
8911 continue;
8912
8913 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8914
8915 /* Since we do not know how big the symbol table is,
8916 we default to reading in the entire file (!) and
8917 processing that. This is overkill, I know, but it
e3c8793a 8918 should work. */
d93f0186 8919 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8920
fb52b2f4
NC		 8921 if (archive_file_offset != 0)
8922 section.sh_size = archive_file_size - section.sh_offset;
8923 else
8924 {
8925 if (fseek (file, 0, SEEK_END))
591a748a 8926 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8927
8928 section.sh_size = ftell (file) - section.sh_offset;
8929 }
252b5132 8930
9ea033b2 8931 if (is_32bit_elf)
9ad5cbcf 8932 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8933 else
9ad5cbcf 8934 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8935 section.sh_name = string_table_length;
252b5132 8936
ba5cdace 8937 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8938 if (num_dynamic_syms < 1)
252b5132
RH		 8939 {
8940 error (_("Unable to determine the number of symbols to load\n"));
8941 continue;
8942 }
252b5132
RH		 8943 }
8944 }
8945
8946 /* Similarly find a string table. */
8947 if (dynamic_strings == NULL)
8948 {
86dba8ee
AM		 8949 for (entry = dynamic_section;
8950 entry < dynamic_section + dynamic_nent;
8951 ++entry)
252b5132
RH		 8952 {
8953 unsigned long offset;
b34976b6 8954 long str_tab_len;
252b5132
RH		 8955
8956 if (entry->d_tag != DT_STRTAB)
8957 continue;
8958
8959 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8960
8961 /* Since we do not know how big the string table is,
8962 we default to reading in the entire file (!) and
8963 processing that. This is overkill, I know, but it
e3c8793a 8964 should work. */
252b5132 8965
d93f0186 8966 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8967
8968 if (archive_file_offset != 0)
8969 str_tab_len = archive_file_size - offset;
8970 else
8971 {
8972 if (fseek (file, 0, SEEK_END))
8973 error (_("Unable to seek to end of file\n"));
8974 str_tab_len = ftell (file) - offset;
8975 }
252b5132
RH		 8976
8977 if (str_tab_len < 1)
8978 {
8979 error
8980 (_("Unable to determine the length of the dynamic string table\n"));
8981 continue;
8982 }
8983
3f5e193b
NC		 8984 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8985 str_tab_len,
8986 _("dynamic string table"));
59245841 8987 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8988 break;
8989 }
8990 }
8991
8992 /* And find the syminfo section if available. */
8993 if (dynamic_syminfo == NULL)
8994 {
3e8bba36 8995 unsigned long syminsz = 0;
252b5132 8996
86dba8ee
AM		 8997 for (entry = dynamic_section;
8998 entry < dynamic_section + dynamic_nent;
8999 ++entry)
252b5132
RH		 9000 {
9001 if (entry->d_tag == DT_SYMINENT)
9002 {
9003 /* Note: these braces are necessary to avoid a syntax
9004 error from the SunOS4 C compiler. */
049b0c3a
NC		 9005 /* PR binutils/17531: A corrupt file can trigger this test.
9006 So do not use an assert, instead generate an error message. */
9007 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9008 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9009 (int) entry->d_un.d_val);
252b5132
RH		 9010 }
9011 else if (entry->d_tag == DT_SYMINSZ)
9012 syminsz = entry->d_un.d_val;
9013 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9014 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9015 syminsz);
252b5132
RH		 9016 }
9017
9018 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9019 {
2cf0635d
NC		 9020 Elf_External_Syminfo * extsyminfo;
9021 Elf_External_Syminfo * extsym;
9022 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9023
9024 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9025 extsyminfo = (Elf_External_Syminfo *)
9026 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9027 _("symbol information"));
a6e9f9df
AM		 9028 if (!extsyminfo)
9029 return 0;
252b5132 9030
3f5e193b 9031 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9032 if (dynamic_syminfo == NULL)
9033 {
8b73c356
NC		 9034 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9035 (unsigned long) syminsz);
252b5132
RH		 9036 return 0;
9037 }
9038
9039 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9040 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9041 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9042 ++syminfo, ++extsym)
252b5132 9043 {
86dba8ee
AM		 9044 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9045 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9046 }
9047
9048 free (extsyminfo);
9049 }
9050 }
9051
9052 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9053 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9054 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9055 if (do_dynamic)
9056 printf (_(" Tag Type Name/Value\n"));
9057
86dba8ee
AM		 9058 for (entry = dynamic_section;
9059 entry < dynamic_section + dynamic_nent;
9060 entry++)
252b5132
RH		 9061 {
9062 if (do_dynamic)
f7a99963 9063 {
2cf0635d 9064 const char * dtype;
e699b9ff 9065
f7a99963
NC		 9066 putchar (' ');
9067 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9068 dtype = get_dynamic_type (entry->d_tag);
9069 printf (" (%s)%*s", dtype,
9070 ((is_32bit_elf ? 27 : 19)
9071 - (int) strlen (dtype)),
f7a99963
NC		 9072 " ");
9073 }
252b5132
RH		 9074
9075 switch (entry->d_tag)
9076 {
d1133906
NC		 9077 case DT_FLAGS:
9078 if (do_dynamic)
e9e44622 9079 print_dynamic_flags (entry->d_un.d_val);
d1133906 9080 break;
76da6bbe 9081
252b5132
RH		 9082 case DT_AUXILIARY:
9083 case DT_FILTER:
019148e4
L		 9084 case DT_CONFIG:
9085 case DT_DEPAUDIT:
9086 case DT_AUDIT:
252b5132
RH		 9087 if (do_dynamic)
9088 {
019148e4 9089 switch (entry->d_tag)
b34976b6 9090 {
019148e4
L		 9091 case DT_AUXILIARY:
9092 printf (_("Auxiliary library"));
9093 break;
9094
9095 case DT_FILTER:
9096 printf (_("Filter library"));
9097 break;
9098
b34976b6 9099 case DT_CONFIG:
019148e4
L		 9100 printf (_("Configuration file"));
9101 break;
9102
9103 case DT_DEPAUDIT:
9104 printf (_("Dependency audit library"));
9105 break;
9106
9107 case DT_AUDIT:
9108 printf (_("Audit library"));
9109 break;
9110 }
252b5132 9111
d79b3d50
NC		 9112 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9113 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9114 else
f7a99963
NC		 9115 {
9116 printf (": ");
9117 print_vma (entry->d_un.d_val, PREFIX_HEX);
9118 putchar ('\n');
9119 }
252b5132
RH		 9120 }
9121 break;
9122
dcefbbbd 9123 case DT_FEATURE:
252b5132
RH		 9124 if (do_dynamic)
9125 {
9126 printf (_("Flags:"));
86f55779 9127
252b5132
RH		 9128 if (entry->d_un.d_val == 0)
9129 printf (_(" None\n"));
9130 else
9131 {
9132 unsigned long int val = entry->d_un.d_val;
86f55779 9133
252b5132
RH		 9134 if (val & DTF_1_PARINIT)
9135 {
9136 printf (" PARINIT");
9137 val ^= DTF_1_PARINIT;
9138 }
dcefbbbd
L		 9139 if (val & DTF_1_CONFEXP)
9140 {
9141 printf (" CONFEXP");
9142 val ^= DTF_1_CONFEXP;
9143 }
252b5132
RH		 9144 if (val != 0)
9145 printf (" %lx", val);
9146 puts ("");
9147 }
9148 }
9149 break;
9150
9151 case DT_POSFLAG_1:
9152 if (do_dynamic)
9153 {
9154 printf (_("Flags:"));
86f55779 9155
252b5132
RH		 9156 if (entry->d_un.d_val == 0)
9157 printf (_(" None\n"));
9158 else
9159 {
9160 unsigned long int val = entry->d_un.d_val;
86f55779 9161
252b5132
RH		 9162 if (val & DF_P1_LAZYLOAD)
9163 {
9164 printf (" LAZYLOAD");
9165 val ^= DF_P1_LAZYLOAD;
9166 }
9167 if (val & DF_P1_GROUPPERM)
9168 {
9169 printf (" GROUPPERM");
9170 val ^= DF_P1_GROUPPERM;
9171 }
9172 if (val != 0)
9173 printf (" %lx", val);
9174 puts ("");
9175 }
9176 }
9177 break;
9178
9179 case DT_FLAGS_1:
9180 if (do_dynamic)
9181 {
9182 printf (_("Flags:"));
9183 if (entry->d_un.d_val == 0)
9184 printf (_(" None\n"));
9185 else
9186 {
9187 unsigned long int val = entry->d_un.d_val;
86f55779 9188
252b5132
RH		 9189 if (val & DF_1_NOW)
9190 {
9191 printf (" NOW");
9192 val ^= DF_1_NOW;
9193 }
9194 if (val & DF_1_GLOBAL)
9195 {
9196 printf (" GLOBAL");
9197 val ^= DF_1_GLOBAL;
9198 }
9199 if (val & DF_1_GROUP)
9200 {
9201 printf (" GROUP");
9202 val ^= DF_1_GROUP;
9203 }
9204 if (val & DF_1_NODELETE)
9205 {
9206 printf (" NODELETE");
9207 val ^= DF_1_NODELETE;
9208 }
9209 if (val & DF_1_LOADFLTR)
9210 {
9211 printf (" LOADFLTR");
9212 val ^= DF_1_LOADFLTR;
9213 }
9214 if (val & DF_1_INITFIRST)
9215 {
9216 printf (" INITFIRST");
9217 val ^= DF_1_INITFIRST;
9218 }
9219 if (val & DF_1_NOOPEN)
9220 {
9221 printf (" NOOPEN");
9222 val ^= DF_1_NOOPEN;
9223 }
9224 if (val & DF_1_ORIGIN)
9225 {
9226 printf (" ORIGIN");
9227 val ^= DF_1_ORIGIN;
9228 }
9229 if (val & DF_1_DIRECT)
9230 {
9231 printf (" DIRECT");
9232 val ^= DF_1_DIRECT;
9233 }
9234 if (val & DF_1_TRANS)
9235 {
9236 printf (" TRANS");
9237 val ^= DF_1_TRANS;
9238 }
9239 if (val & DF_1_INTERPOSE)
9240 {
9241 printf (" INTERPOSE");
9242 val ^= DF_1_INTERPOSE;
9243 }
f7db6139 9244 if (val & DF_1_NODEFLIB)
dcefbbbd 9245 {
f7db6139
L		 9246 printf (" NODEFLIB");
9247 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9248 }
9249 if (val & DF_1_NODUMP)
9250 {
9251 printf (" NODUMP");
9252 val ^= DF_1_NODUMP;
9253 }
34b60028 9254 if (val & DF_1_CONFALT)
dcefbbbd 9255 {
34b60028
L		 9256 printf (" CONFALT");
9257 val ^= DF_1_CONFALT;
9258 }
9259 if (val & DF_1_ENDFILTEE)
9260 {
9261 printf (" ENDFILTEE");
9262 val ^= DF_1_ENDFILTEE;
9263 }
9264 if (val & DF_1_DISPRELDNE)
9265 {
9266 printf (" DISPRELDNE");
9267 val ^= DF_1_DISPRELDNE;
9268 }
9269 if (val & DF_1_DISPRELPND)
9270 {
9271 printf (" DISPRELPND");
9272 val ^= DF_1_DISPRELPND;
9273 }
9274 if (val & DF_1_NODIRECT)
9275 {
9276 printf (" NODIRECT");
9277 val ^= DF_1_NODIRECT;
9278 }
9279 if (val & DF_1_IGNMULDEF)
9280 {
9281 printf (" IGNMULDEF");
9282 val ^= DF_1_IGNMULDEF;
9283 }
9284 if (val & DF_1_NOKSYMS)
9285 {
9286 printf (" NOKSYMS");
9287 val ^= DF_1_NOKSYMS;
9288 }
9289 if (val & DF_1_NOHDR)
9290 {
9291 printf (" NOHDR");
9292 val ^= DF_1_NOHDR;
9293 }
9294 if (val & DF_1_EDITED)
9295 {
9296 printf (" EDITED");
9297 val ^= DF_1_EDITED;
9298 }
9299 if (val & DF_1_NORELOC)
9300 {
9301 printf (" NORELOC");
9302 val ^= DF_1_NORELOC;
9303 }
9304 if (val & DF_1_SYMINTPOSE)
9305 {
9306 printf (" SYMINTPOSE");
9307 val ^= DF_1_SYMINTPOSE;
9308 }
9309 if (val & DF_1_GLOBAUDIT)
9310 {
9311 printf (" GLOBAUDIT");
9312 val ^= DF_1_GLOBAUDIT;
9313 }
9314 if (val & DF_1_SINGLETON)
9315 {
9316 printf (" SINGLETON");
9317 val ^= DF_1_SINGLETON;
dcefbbbd 9318 }
5c383f02
RO		 9319 if (val & DF_1_STUB)
9320 {
9321 printf (" STUB");
9322 val ^= DF_1_STUB;
9323 }
9324 if (val & DF_1_PIE)
9325 {
9326 printf (" PIE");
9327 val ^= DF_1_PIE;
9328 }
252b5132
RH		 9329 if (val != 0)
9330 printf (" %lx", val);
9331 puts ("");
9332 }
9333 }
9334 break;
9335
9336 case DT_PLTREL:
566b0d53 9337 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9338 if (do_dynamic)
9339 puts (get_dynamic_type (entry->d_un.d_val));
9340 break;
9341
9342 case DT_NULL :
9343 case DT_NEEDED :
9344 case DT_PLTGOT :
9345 case DT_HASH :
9346 case DT_STRTAB :
9347 case DT_SYMTAB :
9348 case DT_RELA :
9349 case DT_INIT :
9350 case DT_FINI :
9351 case DT_SONAME :
9352 case DT_RPATH :
9353 case DT_SYMBOLIC:
9354 case DT_REL :
9355 case DT_DEBUG :
9356 case DT_TEXTREL :
9357 case DT_JMPREL :
019148e4 9358 case DT_RUNPATH :
252b5132
RH		 9359 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9360
9361 if (do_dynamic)
9362 {
2cf0635d 9363 char * name;
252b5132 9364
d79b3d50
NC		 9365 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9366 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9367 else
d79b3d50 9368 name = NULL;
252b5132
RH		 9369
9370 if (name)
9371 {
9372 switch (entry->d_tag)
9373 {
9374 case DT_NEEDED:
9375 printf (_("Shared library: [%s]"), name);
9376
18bd398b 9377 if (streq (name, program_interpreter))
f7a99963 9378 printf (_(" program interpreter"));
252b5132
RH		 9379 break;
9380
9381 case DT_SONAME:
f7a99963 9382 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9383 break;
9384
9385 case DT_RPATH:
f7a99963 9386 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9387 break;
9388
019148e4
L		 9389 case DT_RUNPATH:
9390 printf (_("Library runpath: [%s]"), name);
9391 break;
9392
252b5132 9393 default:
f7a99963
NC		 9394 print_vma (entry->d_un.d_val, PREFIX_HEX);
9395 break;
252b5132
RH		 9396 }
9397 }
9398 else
f7a99963
NC		 9399 print_vma (entry->d_un.d_val, PREFIX_HEX);
9400
9401 putchar ('\n');
252b5132
RH		 9402 }
9403 break;
9404
9405 case DT_PLTRELSZ:
9406 case DT_RELASZ :
9407 case DT_STRSZ :
9408 case DT_RELSZ :
9409 case DT_RELAENT :
9410 case DT_SYMENT :
9411 case DT_RELENT :
566b0d53 9412 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9413 case DT_PLTPADSZ:
9414 case DT_MOVEENT :
9415 case DT_MOVESZ :
9416 case DT_INIT_ARRAYSZ:
9417 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9418 case DT_GNU_CONFLICTSZ:
9419 case DT_GNU_LIBLISTSZ:
252b5132 9420 if (do_dynamic)
f7a99963
NC		 9421 {
9422 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9423 printf (_(" (bytes)\n"));
f7a99963 9424 }
252b5132
RH		 9425 break;
9426
9427 case DT_VERDEFNUM:
9428 case DT_VERNEEDNUM:
9429 case DT_RELACOUNT:
9430 case DT_RELCOUNT:
9431 if (do_dynamic)
f7a99963
NC		 9432 {
9433 print_vma (entry->d_un.d_val, UNSIGNED);
9434 putchar ('\n');
9435 }
252b5132
RH		 9436 break;
9437
9438 case DT_SYMINSZ:
9439 case DT_SYMINENT:
9440 case DT_SYMINFO:
9441 case DT_USED:
9442 case DT_INIT_ARRAY:
9443 case DT_FINI_ARRAY:
9444 if (do_dynamic)
9445 {
d79b3d50
NC		 9446 if (entry->d_tag == DT_USED
9447 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9448 {
2cf0635d 9449 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9450
b34976b6 9451 if (*name)
252b5132
RH		 9452 {
9453 printf (_("Not needed object: [%s]\n"), name);
9454 break;
9455 }
9456 }
103f02d3 9457
f7a99963
NC		 9458 print_vma (entry->d_un.d_val, PREFIX_HEX);
9459 putchar ('\n');
252b5132
RH		 9460 }
9461 break;
9462
9463 case DT_BIND_NOW:
9464 /* The value of this entry is ignored. */
35b1837e
AM		 9465 if (do_dynamic)
9466 putchar ('\n');
252b5132 9467 break;
103f02d3 9468
047b2264
JJ		 9469 case DT_GNU_PRELINKED:
9470 if (do_dynamic)
9471 {
2cf0635d 9472 struct tm * tmp;
91d6fa6a 9473 time_t atime = entry->d_un.d_val;
047b2264 9474
91d6fa6a 9475 tmp = gmtime (&atime);
071436c6
NC		 9476 /* PR 17533 file: 041-1244816-0.004. */
9477 if (tmp == NULL)
5a2cbcf4
L		 9478 printf (_("<corrupt time val: %lx"),
9479 (unsigned long) atime);
071436c6
NC		 9480 else
9481 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9482 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9483 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9484
9485 }
9486 break;
9487
fdc90cb4
JJ		 9488 case DT_GNU_HASH:
9489 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9490 if (do_dynamic)
9491 {
9492 print_vma (entry->d_un.d_val, PREFIX_HEX);
9493 putchar ('\n');
9494 }
9495 break;
9496
252b5132
RH		 9497 default:
9498 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9499 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9500 entry->d_un.d_val;
9501
9502 if (do_dynamic)
9503 {
9504 switch (elf_header.e_machine)
9505 {
9506 case EM_MIPS:
4fe85591 9507 case EM_MIPS_RS3_LE:
b2d38a17 9508 dynamic_section_mips_val (entry);
252b5132 9509 break;
103f02d3 9510 case EM_PARISC:
b2d38a17 9511 dynamic_section_parisc_val (entry);
103f02d3 9512 break;
ecc51f48 9513 case EM_IA_64:
b2d38a17 9514 dynamic_section_ia64_val (entry);
ecc51f48 9515 break;
252b5132 9516 default:
f7a99963
NC		 9517 print_vma (entry->d_un.d_val, PREFIX_HEX);
9518 putchar ('\n');
252b5132
RH		 9519 }
9520 }
9521 break;
9522 }
9523 }
9524
9525 return 1;
9526}
9527
9528static char *
d3ba0551 9529get_ver_flags (unsigned int flags)
252b5132 9530{
b34976b6 9531 static char buff[32];
252b5132
RH		 9532
9533 buff[0] = 0;
9534
9535 if (flags == 0)
9536 return _("none");
9537
9538 if (flags & VER_FLG_BASE)
9539 strcat (buff, "BASE ");
9540
9541 if (flags & VER_FLG_WEAK)
9542 {
9543 if (flags & VER_FLG_BASE)
9544 strcat (buff, "| ");
9545
9546 strcat (buff, "WEAK ");
9547 }
9548
44ec90b9
RO		 9549 if (flags & VER_FLG_INFO)
9550 {
9551 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9552 strcat (buff, "| ");
9553
9554 strcat (buff, "INFO ");
9555 }
9556
9557 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9558 strcat (buff, _("| <unknown>"));
252b5132
RH		 9559
9560 return buff;
9561}
9562
9563/* Display the contents of the version sections. */
98fb390a 9564
252b5132 9565static int
2cf0635d 9566process_version_sections (FILE * file)
252b5132 9567{
2cf0635d 9568 Elf_Internal_Shdr * section;
b34976b6
AM		 9569 unsigned i;
9570 int found = 0;
252b5132
RH		 9571
9572 if (! do_version)
9573 return 1;
9574
9575 for (i = 0, section = section_headers;
9576 i < elf_header.e_shnum;
b34976b6 9577 i++, section++)
252b5132
RH		 9578 {
9579 switch (section->sh_type)
9580 {
9581 case SHT_GNU_verdef:
9582 {
2cf0635d 9583 Elf_External_Verdef * edefs;
b34976b6
AM		 9584 unsigned int idx;
9585 unsigned int cnt;
2cf0635d 9586 char * endbuf;
252b5132
RH		 9587
9588 found = 1;
9589
74e1a04b
NC		 9590 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9591 printable_section_name (section),
9592 section->sh_info);
252b5132
RH		 9593
9594 printf (_(" Addr: 0x"));
9595 printf_vma (section->sh_addr);
74e1a04b 9596 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9597 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9598 printable_section_name_from_index (section->sh_link));
252b5132 9599
3f5e193b
NC		 9600 edefs = (Elf_External_Verdef *)
9601 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9602 _("version definition section"));
a6e9f9df
AM		 9603 if (!edefs)
9604 break;
59245841 9605 endbuf = (char *) edefs + section->sh_size;
252b5132 9606
b34976b6 9607 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9608 {
2cf0635d
NC		 9609 char * vstart;
9610 Elf_External_Verdef * edef;
b34976b6 9611 Elf_Internal_Verdef ent;
2cf0635d 9612 Elf_External_Verdaux * eaux;
b34976b6
AM		 9613 Elf_Internal_Verdaux aux;
9614 int j;
9615 int isum;
103f02d3 9616
7e26601c
NC		 9617 /* Check for very large indicies. */
9618 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9619 break;
9620
252b5132 9621 vstart = ((char *) edefs) + idx;
54806181
AM		 9622 if (vstart + sizeof (*edef) > endbuf)
9623 break;
252b5132
RH		 9624
9625 edef = (Elf_External_Verdef *) vstart;
9626
9627 ent.vd_version = BYTE_GET (edef->vd_version);
9628 ent.vd_flags = BYTE_GET (edef->vd_flags);
9629 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9630 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9631 ent.vd_hash = BYTE_GET (edef->vd_hash);
9632 ent.vd_aux = BYTE_GET (edef->vd_aux);
9633 ent.vd_next = BYTE_GET (edef->vd_next);
9634
9635 printf (_(" %#06x: Rev: %d Flags: %s"),
9636 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9637
9638 printf (_(" Index: %d Cnt: %d "),
9639 ent.vd_ndx, ent.vd_cnt);
9640
dd24e3da 9641 /* Check for overflow. */
7e26601c 9642 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9643 break;
9644
252b5132
RH		 9645 vstart += ent.vd_aux;
9646
9647 eaux = (Elf_External_Verdaux *) vstart;
9648
9649 aux.vda_name = BYTE_GET (eaux->vda_name);
9650 aux.vda_next = BYTE_GET (eaux->vda_next);
9651
d79b3d50
NC		 9652 if (VALID_DYNAMIC_NAME (aux.vda_name))
9653 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9654 else
9655 printf (_("Name index: %ld\n"), aux.vda_name);
9656
9657 isum = idx + ent.vd_aux;
9658
b34976b6 9659 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9660 {
dd24e3da 9661 /* Check for overflow. */
7e26601c 9662 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9663 break;
9664
252b5132
RH		 9665 isum += aux.vda_next;
9666 vstart += aux.vda_next;
9667
9668 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9669 if (vstart + sizeof (*eaux) > endbuf)
9670 break;
252b5132
RH		 9671
9672 aux.vda_name = BYTE_GET (eaux->vda_name);
9673 aux.vda_next = BYTE_GET (eaux->vda_next);
9674
d79b3d50 9675 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9676 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9677 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9678 else
9679 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9680 isum, j, aux.vda_name);
9681 }
dd24e3da 9682
54806181
AM		 9683 if (j < ent.vd_cnt)
9684 printf (_(" Version def aux past end of section\n"));
252b5132 9685
5d921cbd
NC		 9686 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9687 if (idx + ent.vd_next <= idx)
9688 break;
9689
252b5132
RH		 9690 idx += ent.vd_next;
9691 }
dd24e3da 9692
54806181
AM		 9693 if (cnt < section->sh_info)
9694 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9695
9696 free (edefs);
9697 }
9698 break;
103f02d3 9699
252b5132
RH		 9700 case SHT_GNU_verneed:
9701 {
2cf0635d 9702 Elf_External_Verneed * eneed;
b34976b6
AM		 9703 unsigned int idx;
9704 unsigned int cnt;
2cf0635d 9705 char * endbuf;
252b5132
RH		 9706
9707 found = 1;
9708
72de5009 9709 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9710 printable_section_name (section), section->sh_info);
252b5132
RH		 9711
9712 printf (_(" Addr: 0x"));
9713 printf_vma (section->sh_addr);
72de5009 9714 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9715 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9716 printable_section_name_from_index (section->sh_link));
252b5132 9717
3f5e193b
NC		 9718 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9719 section->sh_offset, 1,
9720 section->sh_size,
9cf03b7e 9721 _("Version Needs section"));
a6e9f9df
AM		 9722 if (!eneed)
9723 break;
59245841 9724 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9725
9726 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9727 {
2cf0635d 9728 Elf_External_Verneed * entry;
b34976b6
AM		 9729 Elf_Internal_Verneed ent;
9730 int j;
9731 int isum;
2cf0635d 9732 char * vstart;
252b5132 9733
7e26601c 9734 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9735 break;
9736
252b5132 9737 vstart = ((char *) eneed) + idx;
54806181
AM		 9738 if (vstart + sizeof (*entry) > endbuf)
9739 break;
252b5132
RH		 9740
9741 entry = (Elf_External_Verneed *) vstart;
9742
9743 ent.vn_version = BYTE_GET (entry->vn_version);
9744 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9745 ent.vn_file = BYTE_GET (entry->vn_file);
9746 ent.vn_aux = BYTE_GET (entry->vn_aux);
9747 ent.vn_next = BYTE_GET (entry->vn_next);
9748
9749 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9750
d79b3d50
NC		 9751 if (VALID_DYNAMIC_NAME (ent.vn_file))
9752 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9753 else
9754 printf (_(" File: %lx"), ent.vn_file);
9755
9756 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9757
dd24e3da 9758 /* Check for overflow. */
7e26601c 9759 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9760 break;
252b5132
RH		 9761 vstart += ent.vn_aux;
9762
9763 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9764 {
2cf0635d 9765 Elf_External_Vernaux * eaux;
b34976b6 9766 Elf_Internal_Vernaux aux;
252b5132 9767
54806181
AM		 9768 if (vstart + sizeof (*eaux) > endbuf)
9769 break;
252b5132
RH		 9770 eaux = (Elf_External_Vernaux *) vstart;
9771
9772 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9773 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9774 aux.vna_other = BYTE_GET (eaux->vna_other);
9775 aux.vna_name = BYTE_GET (eaux->vna_name);
9776 aux.vna_next = BYTE_GET (eaux->vna_next);
9777
d79b3d50 9778 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9779 printf (_(" %#06x: Name: %s"),
d79b3d50 9780 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9781 else
ecc2063b 9782 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9783 isum, aux.vna_name);
9784
9785 printf (_(" Flags: %s Version: %d\n"),
9786 get_ver_flags (aux.vna_flags), aux.vna_other);
9787
dd24e3da 9788 /* Check for overflow. */
53774b7e
NC		 9789 if (aux.vna_next > (size_t) (endbuf - vstart)
9790 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9791 {
9792 warn (_("Invalid vna_next field of %lx\n"),
9793 aux.vna_next);
9794 j = ent.vn_cnt;
9795 break;
9796 }
252b5132
RH		 9797 isum += aux.vna_next;
9798 vstart += aux.vna_next;
9799 }
9cf03b7e 9800
54806181 9801 if (j < ent.vn_cnt)
9cf03b7e 9802 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9803
bcf83b2a 9804 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9805 {
9806 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9807 cnt = section->sh_info;
9808 break;
9809 }
252b5132
RH		 9810 idx += ent.vn_next;
9811 }
9cf03b7e 9812
54806181 9813 if (cnt < section->sh_info)
9cf03b7e 9814 warn (_("Missing Version Needs information\n"));
103f02d3 9815
252b5132
RH		 9816 free (eneed);
9817 }
9818 break;
9819
9820 case SHT_GNU_versym:
9821 {
2cf0635d 9822 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9823 size_t total;
9824 unsigned int cnt;
2cf0635d
NC		 9825 unsigned char * edata;
9826 unsigned short * data;
9827 char * strtab;
9828 Elf_Internal_Sym * symbols;
9829 Elf_Internal_Shdr * string_sec;
ba5cdace 9830 unsigned long num_syms;
d3ba0551 9831 long off;
252b5132 9832
4fbb74a6 9833 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9834 break;
9835
4fbb74a6 9836 link_section = section_headers + section->sh_link;
08d8fa11 9837 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9838
4fbb74a6 9839 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9840 break;
9841
252b5132
RH		 9842 found = 1;
9843
ba5cdace 9844 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9845 if (symbols == NULL)
9846 break;
252b5132 9847
4fbb74a6 9848 string_sec = section_headers + link_section->sh_link;
252b5132 9849
3f5e193b
NC		 9850 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9851 string_sec->sh_size,
9852 _("version string table"));
a6e9f9df 9853 if (!strtab)
0429c154
MS		 9854 {
9855 free (symbols);
9856 break;
9857 }
252b5132 9858
8b73c356
NC		 9859 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9860 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9861
9862 printf (_(" Addr: "));
9863 printf_vma (section->sh_addr);
72de5009 9864 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9865 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9866 printable_section_name (link_section));
252b5132 9867
d3ba0551
AM		 9868 off = offset_from_vma (file,
9869 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9870 total * sizeof (short));
3f5e193b
NC		 9871 edata = (unsigned char *) get_data (NULL, file, off, total,
9872 sizeof (short),
9873 _("version symbol data"));
a6e9f9df
AM		 9874 if (!edata)
9875 {
9876 free (strtab);
0429c154 9877 free (symbols);
a6e9f9df
AM		 9878 break;
9879 }
252b5132 9880
3f5e193b 9881 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9882
9883 for (cnt = total; cnt --;)
b34976b6
AM		 9884 data[cnt] = byte_get (edata + cnt * sizeof (short),
9885 sizeof (short));
252b5132
RH		 9886
9887 free (edata);
9888
9889 for (cnt = 0; cnt < total; cnt += 4)
9890 {
9891 int j, nn;
ab273396
AM		 9892 char *name;
9893 char *invalid = _("*invalid*");
252b5132
RH		 9894
9895 printf (" %03x:", cnt);
9896
9897 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9898 switch (data[cnt + j])
252b5132
RH		 9899 {
9900 case 0:
9901 fputs (_(" 0 (*local*) "), stdout);
9902 break;
9903
9904 case 1:
9905 fputs (_(" 1 (*global*) "), stdout);
9906 break;
9907
9908 default:
c244d050
NC		 9909 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9910 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9911
dd24e3da 9912 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9913 array, break to avoid an out-of-bounds read. */
9914 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9915 {
9916 warn (_("invalid index into symbol array\n"));
9917 break;
9918 }
9919
ab273396
AM		 9920 name = NULL;
9921 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9922 {
b34976b6
AM		 9923 Elf_Internal_Verneed ivn;
9924 unsigned long offset;
252b5132 9925
d93f0186
NC		 9926 offset = offset_from_vma
9927 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9928 sizeof (Elf_External_Verneed));
252b5132 9929
b34976b6 9930 do
252b5132 9931 {
b34976b6
AM		 9932 Elf_Internal_Vernaux ivna;
9933 Elf_External_Verneed evn;
9934 Elf_External_Vernaux evna;
9935 unsigned long a_off;
252b5132 9936
59245841
NC		 9937 if (get_data (&evn, file, offset, sizeof (evn), 1,
9938 _("version need")) == NULL)
9939 break;
0b4362b0 9940
252b5132
RH		 9941 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9942 ivn.vn_next = BYTE_GET (evn.vn_next);
9943
9944 a_off = offset + ivn.vn_aux;
9945
9946 do
9947 {
59245841
NC		 9948 if (get_data (&evna, file, a_off, sizeof (evna),
9949 1, _("version need aux (2)")) == NULL)
9950 {
9951 ivna.vna_next = 0;
9952 ivna.vna_other = 0;
9953 }
9954 else
9955 {
9956 ivna.vna_next = BYTE_GET (evna.vna_next);
9957 ivna.vna_other = BYTE_GET (evna.vna_other);
9958 }
252b5132
RH		 9959
9960 a_off += ivna.vna_next;
9961 }
b34976b6 9962 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9963 && ivna.vna_next != 0);
9964
b34976b6 9965 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9966 {
9967 ivna.vna_name = BYTE_GET (evna.vna_name);
9968
54806181 9969 if (ivna.vna_name >= string_sec->sh_size)
ab273396 9970 name = invalid;
54806181
AM		 9971 else
9972 name = strtab + ivna.vna_name;
252b5132
RH		 9973 break;
9974 }
9975
9976 offset += ivn.vn_next;
9977 }
9978 while (ivn.vn_next);
9979 }
00d93f34 9980
ab273396 9981 if (data[cnt + j] != 0x8001
b34976b6 9982 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9983 {
b34976b6
AM		 9984 Elf_Internal_Verdef ivd;
9985 Elf_External_Verdef evd;
9986 unsigned long offset;
252b5132 9987
d93f0186
NC		 9988 offset = offset_from_vma
9989 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9990 sizeof evd);
252b5132
RH		 9991
9992 do
9993 {
59245841
NC		 9994 if (get_data (&evd, file, offset, sizeof (evd), 1,
9995 _("version def")) == NULL)
9996 {
9997 ivd.vd_next = 0;
948f632f 9998 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 9999 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10000 break;
59245841
NC		 10001 }
10002 else
10003 {
10004 ivd.vd_next = BYTE_GET (evd.vd_next);
10005 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10006 }
252b5132
RH		 10007
10008 offset += ivd.vd_next;
10009 }
c244d050 10010 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10011 && ivd.vd_next != 0);
10012
c244d050 10013 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10014 {
b34976b6
AM		 10015 Elf_External_Verdaux evda;
10016 Elf_Internal_Verdaux ivda;
252b5132
RH		 10017
10018 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10019
59245841
NC		 10020 if (get_data (&evda, file,
10021 offset - ivd.vd_next + ivd.vd_aux,
10022 sizeof (evda), 1,
10023 _("version def aux")) == NULL)
10024 break;
252b5132
RH		 10025
10026 ivda.vda_name = BYTE_GET (evda.vda_name);
10027
54806181 10028 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10029 name = invalid;
10030 else if (name != NULL && name != invalid)
10031 name = _("*both*");
54806181
AM		 10032 else
10033 name = strtab + ivda.vda_name;
252b5132
RH		 10034 }
10035 }
ab273396
AM		 10036 if (name != NULL)
10037 nn += printf ("(%s%-*s",
10038 name,
10039 12 - (int) strlen (name),
10040 ")");
252b5132
RH		 10041
10042 if (nn < 18)
10043 printf ("%*c", 18 - nn, ' ');
10044 }
10045
10046 putchar ('\n');
10047 }
10048
10049 free (data);
10050 free (strtab);
10051 free (symbols);
10052 }
10053 break;
103f02d3 10054
252b5132
RH		 10055 default:
10056 break;
10057 }
10058 }
10059
10060 if (! found)
10061 printf (_("\nNo version information found in this file.\n"));
10062
10063 return 1;
10064}
10065
d1133906 10066static const char *
d3ba0551 10067get_symbol_binding (unsigned int binding)
252b5132 10068{
b34976b6 10069 static char buff[32];
252b5132
RH		 10070
10071 switch (binding)
10072 {
b34976b6
AM		 10073 case STB_LOCAL: return "LOCAL";
10074 case STB_GLOBAL: return "GLOBAL";
10075 case STB_WEAK: return "WEAK";
252b5132
RH		 10076 default:
10077 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10078 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10079 binding);
252b5132 10080 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10081 {
10082 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10083 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10084 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10085 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10086 return "UNIQUE";
10087 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10088 }
252b5132 10089 else
e9e44622 10090 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10091 return buff;
10092 }
10093}
10094
d1133906 10095static const char *
d3ba0551 10096get_symbol_type (unsigned int type)
252b5132 10097{
b34976b6 10098 static char buff[32];
252b5132
RH		 10099
10100 switch (type)
10101 {
b34976b6
AM		 10102 case STT_NOTYPE: return "NOTYPE";
10103 case STT_OBJECT: return "OBJECT";
10104 case STT_FUNC: return "FUNC";
10105 case STT_SECTION: return "SECTION";
10106 case STT_FILE: return "FILE";
10107 case STT_COMMON: return "COMMON";
10108 case STT_TLS: return "TLS";
15ab5209
DB		 10109 case STT_RELC: return "RELC";
10110 case STT_SRELC: return "SRELC";
252b5132
RH		 10111 default:
10112 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10113 {
3510a7b8
NC		 10114 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10115 return "THUMB_FUNC";
103f02d3 10116
351b4b40 10117 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10118 return "REGISTER";
10119
10120 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10121 return "PARISC_MILLI";
10122
e9e44622 10123 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10124 }
252b5132 10125 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10126 {
10127 if (elf_header.e_machine == EM_PARISC)
10128 {
10129 if (type == STT_HP_OPAQUE)
10130 return "HP_OPAQUE";
10131 if (type == STT_HP_STUB)
10132 return "HP_STUB";
10133 }
10134
d8045f23 10135 if (type == STT_GNU_IFUNC
9c55345c 10136 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10137 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10138 /* GNU is still using the default value 0. */
d8045f23
NC		 10139 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10140 return "IFUNC";
10141
e9e44622 10142 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10143 }
252b5132 10144 else
e9e44622 10145 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10146 return buff;
10147 }
10148}
10149
d1133906 10150static const char *
d3ba0551 10151get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10152{
10153 switch (visibility)
10154 {
b34976b6
AM		 10155 case STV_DEFAULT: return "DEFAULT";
10156 case STV_INTERNAL: return "INTERNAL";
10157 case STV_HIDDEN: return "HIDDEN";
d1133906 10158 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10159 default:
10160 error (_("Unrecognized visibility value: %u"), visibility);
10161 return _("<unknown>");
d1133906
NC		 10162 }
10163}
10164
5e2b0d47
NC		 10165static const char *
10166get_mips_symbol_other (unsigned int other)
10167{
10168 switch (other)
10169 {
df58fc94
RS		 10170 case STO_OPTIONAL:
10171 return "OPTIONAL";
10172 case STO_MIPS_PLT:
10173 return "MIPS PLT";
10174 case STO_MIPS_PIC:
10175 return "MIPS PIC";
10176 case STO_MICROMIPS:
10177 return "MICROMIPS";
10178 case STO_MICROMIPS | STO_MIPS_PIC:
10179 return "MICROMIPS, MIPS PIC";
10180 case STO_MIPS16:
10181 return "MIPS16";
10182 default:
10183 return NULL;
5e2b0d47
NC		 10184 }
10185}
10186
28f997cf
TG		 10187static const char *
10188get_ia64_symbol_other (unsigned int other)
10189{
10190 if (is_ia64_vms ())
10191 {
10192 static char res[32];
10193
10194 res[0] = 0;
10195
10196 /* Function types is for images and .STB files only. */
10197 switch (elf_header.e_type)
10198 {
10199 case ET_DYN:
10200 case ET_EXEC:
10201 switch (VMS_ST_FUNC_TYPE (other))
10202 {
10203 case VMS_SFT_CODE_ADDR:
10204 strcat (res, " CA");
10205 break;
10206 case VMS_SFT_SYMV_IDX:
10207 strcat (res, " VEC");
10208 break;
10209 case VMS_SFT_FD:
10210 strcat (res, " FD");
10211 break;
10212 case VMS_SFT_RESERVE:
10213 strcat (res, " RSV");
10214 break;
10215 default:
bee0ee85
NC		 10216 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10217 VMS_ST_FUNC_TYPE (other));
10218 strcat (res, " <unknown>");
10219 break;
28f997cf
TG		 10220 }
10221 break;
10222 default:
10223 break;
10224 }
10225 switch (VMS_ST_LINKAGE (other))
10226 {
10227 case VMS_STL_IGNORE:
10228 strcat (res, " IGN");
10229 break;
10230 case VMS_STL_RESERVE:
10231 strcat (res, " RSV");
10232 break;
10233 case VMS_STL_STD:
10234 strcat (res, " STD");
10235 break;
10236 case VMS_STL_LNK:
10237 strcat (res, " LNK");
10238 break;
10239 default:
bee0ee85
NC		 10240 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10241 VMS_ST_LINKAGE (other));
10242 strcat (res, " <unknown>");
10243 break;
28f997cf
TG		 10244 }
10245
10246 if (res[0] != 0)
10247 return res + 1;
10248 else
10249 return res;
10250 }
10251 return NULL;
10252}
10253
6911b7dc
AM		 10254static const char *
10255get_ppc64_symbol_other (unsigned int other)
10256{
10257 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10258 {
10259 static char buf[32];
10260 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10261 PPC64_LOCAL_ENTRY_OFFSET (other));
10262 return buf;
10263 }
10264 return NULL;
10265}
10266
5e2b0d47
NC		 10267static const char *
10268get_symbol_other (unsigned int other)
10269{
10270 const char * result = NULL;
10271 static char buff [32];
10272
10273 if (other == 0)
10274 return "";
10275
10276 switch (elf_header.e_machine)
10277 {
10278 case EM_MIPS:
10279 result = get_mips_symbol_other (other);
28f997cf
TG		 10280 break;
10281 case EM_IA_64:
10282 result = get_ia64_symbol_other (other);
10283 break;
6911b7dc
AM		 10284 case EM_PPC64:
10285 result = get_ppc64_symbol_other (other);
10286 break;
5e2b0d47
NC		 10287 default:
10288 break;
10289 }
10290
10291 if (result)
10292 return result;
10293
10294 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10295 return buff;
10296}
10297
d1133906 10298static const char *
d3ba0551 10299get_symbol_index_type (unsigned int type)
252b5132 10300{
b34976b6 10301 static char buff[32];
5cf1065c 10302
252b5132
RH		 10303 switch (type)
10304 {
b34976b6
AM		 10305 case SHN_UNDEF: return "UND";
10306 case SHN_ABS: return "ABS";
10307 case SHN_COMMON: return "COM";
252b5132 10308 default:
9ce701e2
L		 10309 if (type == SHN_IA_64_ANSI_COMMON
10310 && elf_header.e_machine == EM_IA_64
10311 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10312 return "ANSI_COM";
8a9036a4 10313 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10314 || elf_header.e_machine == EM_L1OM
10315 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10316 && type == SHN_X86_64_LCOMMON)
10317 return "LARGE_COM";
ac145307
BS		 10318 else if ((type == SHN_MIPS_SCOMMON
10319 && elf_header.e_machine == EM_MIPS)
10320 || (type == SHN_TIC6X_SCOMMON
10321 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10322 return "SCOM";
10323 else if (type == SHN_MIPS_SUNDEFINED
10324 && elf_header.e_machine == EM_MIPS)
10325 return "SUND";
9ce701e2 10326 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10327 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10328 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10329 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10330 else if (type >= SHN_LORESERVE)
10331 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10332 else if (type >= elf_header.e_shnum)
e0a31db1 10333 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10334 else
232e7cb8 10335 sprintf (buff, "%3d", type);
5cf1065c 10336 break;
252b5132 10337 }
5cf1065c
NC		 10338
10339 return buff;
252b5132
RH		 10340}
10341
66543521 10342static bfd_vma *
57028622 10343get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10344{
2cf0635d
NC		 10345 unsigned char * e_data;
10346 bfd_vma * i_data;
252b5132 10347
57028622
NC		 10348 /* If the size_t type is smaller than the bfd_size_type, eg because
10349 you are building a 32-bit tool on a 64-bit host, then make sure
10350 that when (number) is cast to (size_t) no information is lost. */
10351 if (sizeof (size_t) < sizeof (bfd_size_type)
10352 && (bfd_size_type) ((size_t) number) != number)
10353 {
10354 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10355 (unsigned long long) number, ent_size);
10356 return NULL;
10357 }
948f632f 10358
3102e897
NC		 10359 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10360 attempting to allocate memory when the read is bound to fail. */
10361 if (ent_size * number > current_file_size)
10362 {
57028622
NC		 10363 error (_("Invalid number of dynamic entries: %llu\n"),
10364 (unsigned long long) number);
3102e897
NC		 10365 return NULL;
10366 }
10367
57028622 10368 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10369 if (e_data == NULL)
10370 {
57028622
NC		 10371 error (_("Out of memory reading %llu dynamic entries\n"),
10372 (unsigned long long) number);
252b5132
RH		 10373 return NULL;
10374 }
10375
57028622 10376 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10377 {
57028622
NC		 10378 error (_("Unable to read in %llu bytes of dynamic data\n"),
10379 (unsigned long long) (number * ent_size));
3102e897 10380 free (e_data);
252b5132
RH		 10381 return NULL;
10382 }
10383
57028622 10384 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10385 if (i_data == NULL)
10386 {
57028622
NC		 10387 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10388 (unsigned long long) number);
252b5132
RH		 10389 free (e_data);
10390 return NULL;
10391 }
10392
10393 while (number--)
66543521 10394 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10395
10396 free (e_data);
10397
10398 return i_data;
10399}
10400
6bd1a22c
L		 10401static void
10402print_dynamic_symbol (bfd_vma si, unsigned long hn)
10403{
2cf0635d 10404 Elf_Internal_Sym * psym;
6bd1a22c
L		 10405 int n;
10406
6bd1a22c
L		 10407 n = print_vma (si, DEC_5);
10408 if (n < 5)
0b4362b0 10409 fputs (&" "[n], stdout);
6bd1a22c 10410 printf (" %3lu: ", hn);
e0a31db1
NC		 10411
10412 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10413 {
3102e897
NC		 10414 printf (_("<No info available for dynamic symbol number %lu>\n"),
10415 (unsigned long) si);
e0a31db1
NC		 10416 return;
10417 }
10418
10419 psym = dynamic_symbols + si;
6bd1a22c
L		 10420 print_vma (psym->st_value, LONG_HEX);
10421 putchar (' ');
10422 print_vma (psym->st_size, DEC_5);
10423
f4be36b3
AM		 10424 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10425 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10426 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10427 /* Check to see if any other bits in the st_other field are set.
10428 Note - displaying this information disrupts the layout of the
10429 table being generated, but for the moment this case is very
10430 rare. */
10431 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10432 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10433 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10434 if (VALID_DYNAMIC_NAME (psym->st_name))
10435 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10436 else
2b692964 10437 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10438 putchar ('\n');
10439}
10440
bb4d2ac2
L		 10441static const char *
10442get_symbol_version_string (FILE *file, int is_dynsym,
10443 const char *strtab,
10444 unsigned long int strtab_size,
10445 unsigned int si, Elf_Internal_Sym *psym,
10446 enum versioned_symbol_info *sym_info,
10447 unsigned short *vna_other)
10448{
ab273396
AM		 10449 unsigned char data[2];
10450 unsigned short vers_data;
10451 unsigned long offset;
bb4d2ac2 10452
ab273396
AM		 10453 if (!is_dynsym
10454 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10455 return NULL;
bb4d2ac2 10456
ab273396
AM		 10457 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10458 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10459
ab273396
AM		 10460 if (get_data (&data, file, offset + si * sizeof (vers_data),
10461 sizeof (data), 1, _("version data")) == NULL)
10462 return NULL;
10463
10464 vers_data = byte_get (data, 2);
bb4d2ac2 10465
ab273396
AM		 10466 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10467 return NULL;
bb4d2ac2 10468
ab273396
AM		 10469 /* Usually we'd only see verdef for defined symbols, and verneed for
10470 undefined symbols. However, symbols defined by the linker in
10471 .dynbss for variables copied from a shared library in order to
10472 avoid text relocations are defined yet have verneed. We could
10473 use a heuristic to detect the special case, for example, check
10474 for verneed first on symbols defined in SHT_NOBITS sections, but
10475 it is simpler and more reliable to just look for both verdef and
10476 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10477
ab273396
AM		 10478 if (psym->st_shndx != SHN_UNDEF
10479 && vers_data != 0x8001
10480 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10481 {
10482 Elf_Internal_Verdef ivd;
10483 Elf_Internal_Verdaux ivda;
10484 Elf_External_Verdaux evda;
10485 unsigned long off;
bb4d2ac2 10486
ab273396
AM		 10487 off = offset_from_vma (file,
10488 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10489 sizeof (Elf_External_Verdef));
10490
10491 do
bb4d2ac2 10492 {
ab273396
AM		 10493 Elf_External_Verdef evd;
10494
10495 if (get_data (&evd, file, off, sizeof (evd), 1,
10496 _("version def")) == NULL)
10497 {
10498 ivd.vd_ndx = 0;
10499 ivd.vd_aux = 0;
10500 ivd.vd_next = 0;
10501 }
10502 else
bb4d2ac2 10503 {
ab273396
AM		 10504 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10505 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10506 ivd.vd_next = BYTE_GET (evd.vd_next);
10507 }
bb4d2ac2 10508
ab273396
AM		 10509 off += ivd.vd_next;
10510 }
10511 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10512
ab273396
AM		 10513 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10514 {
10515 off -= ivd.vd_next;
10516 off += ivd.vd_aux;
bb4d2ac2 10517
ab273396
AM		 10518 if (get_data (&evda, file, off, sizeof (evda), 1,
10519 _("version def aux")) != NULL)
10520 {
10521 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10522
ab273396
AM		 10523 if (psym->st_name != ivda.vda_name)
10524 {
10525 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10526 ? symbol_hidden : symbol_public);
10527 return (ivda.vda_name < strtab_size
10528 ? strtab + ivda.vda_name : _("<corrupt>"));
10529 }
10530 }
10531 }
10532 }
bb4d2ac2 10533
ab273396
AM		 10534 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10535 {
10536 Elf_External_Verneed evn;
10537 Elf_Internal_Verneed ivn;
10538 Elf_Internal_Vernaux ivna;
bb4d2ac2 10539
ab273396
AM		 10540 offset = offset_from_vma (file,
10541 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10542 sizeof evn);
10543 do
10544 {
10545 unsigned long vna_off;
bb4d2ac2 10546
ab273396
AM		 10547 if (get_data (&evn, file, offset, sizeof (evn), 1,
10548 _("version need")) == NULL)
10549 {
10550 ivna.vna_next = 0;
10551 ivna.vna_other = 0;
10552 ivna.vna_name = 0;
10553 break;
10554 }
bb4d2ac2 10555
ab273396
AM		 10556 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10557 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10558
ab273396 10559 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10560
ab273396
AM		 10561 do
10562 {
10563 Elf_External_Vernaux evna;
bb4d2ac2 10564
ab273396
AM		 10565 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10566 _("version need aux (3)")) == NULL)
bb4d2ac2 10567 {
ab273396
AM		 10568 ivna.vna_next = 0;
10569 ivna.vna_other = 0;
10570 ivna.vna_name = 0;
bb4d2ac2 10571 }
bb4d2ac2 10572 else
bb4d2ac2 10573 {
ab273396
AM		 10574 ivna.vna_other = BYTE_GET (evna.vna_other);
10575 ivna.vna_next = BYTE_GET (evna.vna_next);
10576 ivna.vna_name = BYTE_GET (evna.vna_name);
10577 }
bb4d2ac2 10578
ab273396
AM		 10579 vna_off += ivna.vna_next;
10580 }
10581 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10582
ab273396
AM		 10583 if (ivna.vna_other == vers_data)
10584 break;
bb4d2ac2 10585
ab273396
AM		 10586 offset += ivn.vn_next;
10587 }
10588 while (ivn.vn_next != 0);
bb4d2ac2 10589
ab273396
AM		 10590 if (ivna.vna_other == vers_data)
10591 {
10592 *sym_info = symbol_undefined;
10593 *vna_other = ivna.vna_other;
10594 return (ivna.vna_name < strtab_size
10595 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10596 }
10597 }
ab273396 10598 return NULL;
bb4d2ac2
L		 10599}
10600
e3c8793a 10601/* Dump the symbol table. */
252b5132 10602static int
2cf0635d 10603process_symbol_table (FILE * file)
252b5132 10604{
2cf0635d 10605 Elf_Internal_Shdr * section;
8b73c356
NC		 10606 bfd_size_type nbuckets = 0;
10607 bfd_size_type nchains = 0;
2cf0635d
NC		 10608 bfd_vma * buckets = NULL;
10609 bfd_vma * chains = NULL;
fdc90cb4 10610 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10611 bfd_vma * gnubuckets = NULL;
10612 bfd_vma * gnuchains = NULL;
6bd1a22c 10613 bfd_vma gnusymidx = 0;
071436c6 10614 bfd_size_type ngnuchains = 0;
252b5132 10615
2c610e4b 10616 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10617 return 1;
10618
6bd1a22c
L		 10619 if (dynamic_info[DT_HASH]
10620 && (do_histogram
2c610e4b
L		 10621 || (do_using_dynamic
10622 && !do_dyn_syms
10623 && dynamic_strings != NULL)))
252b5132 10624 {
66543521
AM		 10625 unsigned char nb[8];
10626 unsigned char nc[8];
8b73c356 10627 unsigned int hash_ent_size = 4;
66543521
AM		 10628
10629 if ((elf_header.e_machine == EM_ALPHA
10630 || elf_header.e_machine == EM_S390
10631 || elf_header.e_machine == EM_S390_OLD)
10632 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10633 hash_ent_size = 8;
10634
fb52b2f4
NC		 10635 if (fseek (file,
10636 (archive_file_offset
10637 + offset_from_vma (file, dynamic_info[DT_HASH],
10638 sizeof nb + sizeof nc)),
d93f0186 10639 SEEK_SET))
252b5132 10640 {
591a748a 10641 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10642 goto no_hash;
252b5132
RH		 10643 }
10644
66543521 10645 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10646 {
10647 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10648 goto no_hash;
252b5132
RH		 10649 }
10650
66543521 10651 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10652 {
10653 error (_("Failed to read in number of chains\n"));
d3a44ec6 10654 goto no_hash;
252b5132
RH		 10655 }
10656
66543521
AM		 10657 nbuckets = byte_get (nb, hash_ent_size);
10658 nchains = byte_get (nc, hash_ent_size);
252b5132 10659
66543521
AM		 10660 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10661 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10662
d3a44ec6 10663 no_hash:
252b5132 10664 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10665 {
10666 if (do_using_dynamic)
10667 return 0;
10668 free (buckets);
10669 free (chains);
10670 buckets = NULL;
10671 chains = NULL;
10672 nbuckets = 0;
10673 nchains = 0;
10674 }
252b5132
RH		 10675 }
10676
6bd1a22c
L		 10677 if (dynamic_info_DT_GNU_HASH
10678 && (do_histogram
2c610e4b
L		 10679 || (do_using_dynamic
10680 && !do_dyn_syms
10681 && dynamic_strings != NULL)))
252b5132 10682 {
6bd1a22c
L		 10683 unsigned char nb[16];
10684 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10685 bfd_vma buckets_vma;
10686
10687 if (fseek (file,
10688 (archive_file_offset
10689 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10690 sizeof nb)),
10691 SEEK_SET))
10692 {
10693 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10694 goto no_gnu_hash;
6bd1a22c 10695 }
252b5132 10696
6bd1a22c
L		 10697 if (fread (nb, 16, 1, file) != 1)
10698 {
10699 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10700 goto no_gnu_hash;
6bd1a22c
L		 10701 }
10702
10703 ngnubuckets = byte_get (nb, 4);
10704 gnusymidx = byte_get (nb + 4, 4);
10705 bitmaskwords = byte_get (nb + 8, 4);
10706 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10707 if (is_32bit_elf)
6bd1a22c 10708 buckets_vma += bitmaskwords * 4;
f7a99963 10709 else
6bd1a22c 10710 buckets_vma += bitmaskwords * 8;
252b5132 10711
6bd1a22c
L		 10712 if (fseek (file,
10713 (archive_file_offset
10714 + offset_from_vma (file, buckets_vma, 4)),
10715 SEEK_SET))
252b5132 10716 {
6bd1a22c 10717 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10718 goto no_gnu_hash;
6bd1a22c
L		 10719 }
10720
10721 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10722
6bd1a22c 10723 if (gnubuckets == NULL)
d3a44ec6 10724 goto no_gnu_hash;
6bd1a22c
L		 10725
10726 for (i = 0; i < ngnubuckets; i++)
10727 if (gnubuckets[i] != 0)
10728 {
10729 if (gnubuckets[i] < gnusymidx)
10730 return 0;
10731
10732 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10733 maxchain = gnubuckets[i];
10734 }
10735
10736 if (maxchain == 0xffffffff)
d3a44ec6 10737 goto no_gnu_hash;
6bd1a22c
L		 10738
10739 maxchain -= gnusymidx;
10740
10741 if (fseek (file,
10742 (archive_file_offset
10743 + offset_from_vma (file, buckets_vma
10744 + 4 * (ngnubuckets + maxchain), 4)),
10745 SEEK_SET))
10746 {
10747 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10748 goto no_gnu_hash;
6bd1a22c
L		 10749 }
10750
10751 do
10752 {
10753 if (fread (nb, 4, 1, file) != 1)
252b5132 10754 {
6bd1a22c 10755 error (_("Failed to determine last chain length\n"));
d3a44ec6 10756 goto no_gnu_hash;
6bd1a22c 10757 }
252b5132 10758
6bd1a22c 10759 if (maxchain + 1 == 0)
d3a44ec6 10760 goto no_gnu_hash;
252b5132 10761
6bd1a22c
L		 10762 ++maxchain;
10763 }
10764 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10765
6bd1a22c
L		 10766 if (fseek (file,
10767 (archive_file_offset
10768 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10769 SEEK_SET))
10770 {
10771 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10772 goto no_gnu_hash;
6bd1a22c
L		 10773 }
10774
10775 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10776 ngnuchains = maxchain;
6bd1a22c 10777
d3a44ec6 10778 no_gnu_hash:
6bd1a22c 10779 if (gnuchains == NULL)
d3a44ec6
JJ		 10780 {
10781 free (gnubuckets);
d3a44ec6
JJ		 10782 gnubuckets = NULL;
10783 ngnubuckets = 0;
f64fddf1
NC		 10784 if (do_using_dynamic)
10785 return 0;
d3a44ec6 10786 }
6bd1a22c
L		 10787 }
10788
10789 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10790 && do_syms
10791 && do_using_dynamic
3102e897
NC		 10792 && dynamic_strings != NULL
10793 && dynamic_symbols != NULL)
6bd1a22c
L		 10794 {
10795 unsigned long hn;
10796
10797 if (dynamic_info[DT_HASH])
10798 {
10799 bfd_vma si;
10800
10801 printf (_("\nSymbol table for image:\n"));
10802 if (is_32bit_elf)
10803 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10804 else
10805 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10806
10807 for (hn = 0; hn < nbuckets; hn++)
10808 {
10809 if (! buckets[hn])
10810 continue;
10811
10812 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10813 print_dynamic_symbol (si, hn);
252b5132
RH		 10814 }
10815 }
6bd1a22c
L		 10816
10817 if (dynamic_info_DT_GNU_HASH)
10818 {
10819 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10820 if (is_32bit_elf)
10821 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10822 else
10823 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10824
10825 for (hn = 0; hn < ngnubuckets; ++hn)
10826 if (gnubuckets[hn] != 0)
10827 {
10828 bfd_vma si = gnubuckets[hn];
10829 bfd_vma off = si - gnusymidx;
10830
10831 do
10832 {
10833 print_dynamic_symbol (si, hn);
10834 si++;
10835 }
071436c6 10836 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10837 }
10838 }
252b5132 10839 }
8b73c356
NC		 10840 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10841 && section_headers != NULL)
252b5132 10842 {
b34976b6 10843 unsigned int i;
252b5132
RH		 10844
10845 for (i = 0, section = section_headers;
10846 i < elf_header.e_shnum;
10847 i++, section++)
10848 {
b34976b6 10849 unsigned int si;
2cf0635d 10850 char * strtab = NULL;
c256ffe7 10851 unsigned long int strtab_size = 0;
2cf0635d
NC		 10852 Elf_Internal_Sym * symtab;
10853 Elf_Internal_Sym * psym;
ba5cdace 10854 unsigned long num_syms;
252b5132 10855
2c610e4b
L		 10856 if ((section->sh_type != SHT_SYMTAB
10857 && section->sh_type != SHT_DYNSYM)
10858 || (!do_syms
10859 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10860 continue;
10861
dd24e3da
NC		 10862 if (section->sh_entsize == 0)
10863 {
10864 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10865 printable_section_name (section));
dd24e3da
NC		 10866 continue;
10867 }
10868
252b5132 10869 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10870 printable_section_name (section),
252b5132 10871 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10872
f7a99963 10873 if (is_32bit_elf)
ca47b30c 10874 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10875 else
ca47b30c 10876 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10877
ba5cdace 10878 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10879 if (symtab == NULL)
10880 continue;
10881
10882 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10883 {
10884 strtab = string_table;
10885 strtab_size = string_table_length;
10886 }
4fbb74a6 10887 else if (section->sh_link < elf_header.e_shnum)
252b5132 10888 {
2cf0635d 10889 Elf_Internal_Shdr * string_sec;
252b5132 10890
4fbb74a6 10891 string_sec = section_headers + section->sh_link;
252b5132 10892
3f5e193b
NC		 10893 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10894 1, string_sec->sh_size,
10895 _("string table"));
c256ffe7 10896 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10897 }
10898
ba5cdace 10899 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10900 {
bb4d2ac2
L		 10901 const char *version_string;
10902 enum versioned_symbol_info sym_info;
10903 unsigned short vna_other;
10904
5e220199 10905 printf ("%6d: ", si);
f7a99963
NC		 10906 print_vma (psym->st_value, LONG_HEX);
10907 putchar (' ');
10908 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10909 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10910 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10911 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10912 /* Check to see if any other bits in the st_other field are set.
10913 Note - displaying this information disrupts the layout of the
10914 table being generated, but for the moment this case is very rare. */
10915 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10916 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10917 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10918 print_symbol (25, psym->st_name < strtab_size
2b692964 10919 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10920
bb4d2ac2
L		 10921 version_string
10922 = get_symbol_version_string (file,
10923 section->sh_type == SHT_DYNSYM,
10924 strtab, strtab_size, si,
10925 psym, &sym_info, &vna_other);
10926 if (version_string)
252b5132 10927 {
bb4d2ac2
L		 10928 if (sym_info == symbol_undefined)
10929 printf ("@%s (%d)", version_string, vna_other);
10930 else
10931 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10932 version_string);
252b5132
RH		 10933 }
10934
10935 putchar ('\n');
10936 }
10937
10938 free (symtab);
10939 if (strtab != string_table)
10940 free (strtab);
10941 }
10942 }
10943 else if (do_syms)
10944 printf
10945 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10946
10947 if (do_histogram && buckets != NULL)
10948 {
2cf0635d
NC		 10949 unsigned long * lengths;
10950 unsigned long * counts;
66543521
AM		 10951 unsigned long hn;
10952 bfd_vma si;
10953 unsigned long maxlength = 0;
10954 unsigned long nzero_counts = 0;
10955 unsigned long nsyms = 0;
94d15024 10956 unsigned long chained;
252b5132 10957
66543521
AM		 10958 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10959 (unsigned long) nbuckets);
252b5132 10960
3f5e193b 10961 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10962 if (lengths == NULL)
10963 {
8b73c356 10964 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10965 return 0;
10966 }
8b73c356
NC		 10967
10968 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10969 for (hn = 0; hn < nbuckets; ++hn)
10970 {
94d15024
MF		 10971 for (si = buckets[hn], chained = 0;
10972 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10973 si = chains[si], ++chained)
252b5132 10974 {
b34976b6 10975 ++nsyms;
252b5132 10976 if (maxlength < ++lengths[hn])
b34976b6 10977 ++maxlength;
252b5132 10978 }
94d15024
MF		 10979
10980 /* PR binutils/17531: A corrupt binary could contain broken
10981 histogram data. Do not go into an infinite loop trying
10982 to process it. */
10983 if (chained > nchains)
10984 {
10985 error (_("histogram chain is corrupt\n"));
10986 break;
10987 }
252b5132
RH		 10988 }
10989
3f5e193b 10990 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10991 if (counts == NULL)
10992 {
b2e951ec 10993 free (lengths);
8b73c356 10994 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10995 return 0;
10996 }
10997
10998 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 10999 ++counts[lengths[hn]];
252b5132 11000
103f02d3 11001 if (nbuckets > 0)
252b5132 11002 {
66543521
AM		 11003 unsigned long i;
11004 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11005 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11006 for (i = 1; i <= maxlength; ++i)
103f02d3 11007 {
66543521
AM		 11008 nzero_counts += counts[i] * i;
11009 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11010 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11011 (nzero_counts * 100.0) / nsyms);
11012 }
252b5132
RH		 11013 }
11014
11015 free (counts);
11016 free (lengths);
11017 }
11018
11019 if (buckets != NULL)
11020 {
11021 free (buckets);
11022 free (chains);
11023 }
11024
d3a44ec6 11025 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11026 {
2cf0635d
NC		 11027 unsigned long * lengths;
11028 unsigned long * counts;
fdc90cb4
JJ		 11029 unsigned long hn;
11030 unsigned long maxlength = 0;
11031 unsigned long nzero_counts = 0;
11032 unsigned long nsyms = 0;
fdc90cb4 11033
8b73c356
NC		 11034 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11035 (unsigned long) ngnubuckets);
11036
3f5e193b 11037 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11038 if (lengths == NULL)
11039 {
8b73c356 11040 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11041 return 0;
11042 }
11043
fdc90cb4
JJ		 11044 printf (_(" Length Number %% of total Coverage\n"));
11045
11046 for (hn = 0; hn < ngnubuckets; ++hn)
11047 if (gnubuckets[hn] != 0)
11048 {
11049 bfd_vma off, length = 1;
11050
6bd1a22c 11051 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11052 /* PR 17531 file: 010-77222-0.004. */
11053 off < ngnuchains && (gnuchains[off] & 1) == 0;
11054 ++off)
fdc90cb4
JJ		 11055 ++length;
11056 lengths[hn] = length;
11057 if (length > maxlength)
11058 maxlength = length;
11059 nsyms += length;
11060 }
11061
3f5e193b 11062 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11063 if (counts == NULL)
11064 {
b2e951ec 11065 free (lengths);
8b73c356 11066 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11067 return 0;
11068 }
11069
11070 for (hn = 0; hn < ngnubuckets; ++hn)
11071 ++counts[lengths[hn]];
11072
11073 if (ngnubuckets > 0)
11074 {
11075 unsigned long j;
11076 printf (" 0 %-10lu (%5.1f%%)\n",
11077 counts[0], (counts[0] * 100.0) / ngnubuckets);
11078 for (j = 1; j <= maxlength; ++j)
11079 {
11080 nzero_counts += counts[j] * j;
11081 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11082 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11083 (nzero_counts * 100.0) / nsyms);
11084 }
11085 }
11086
11087 free (counts);
11088 free (lengths);
11089 free (gnubuckets);
11090 free (gnuchains);
11091 }
11092
252b5132
RH		 11093 return 1;
11094}
11095
11096static int
2cf0635d 11097process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11098{
b4c96d0d 11099 unsigned int i;
252b5132
RH		 11100
11101 if (dynamic_syminfo == NULL
11102 || !do_dynamic)
11103 /* No syminfo, this is ok. */
11104 return 1;
11105
11106 /* There better should be a dynamic symbol section. */
11107 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11108 return 0;
11109
11110 if (dynamic_addr)
11111 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11112 dynamic_syminfo_offset, dynamic_syminfo_nent);
11113
11114 printf (_(" Num: Name BoundTo Flags\n"));
11115 for (i = 0; i < dynamic_syminfo_nent; ++i)
11116 {
11117 unsigned short int flags = dynamic_syminfo[i].si_flags;
11118
31104126 11119 printf ("%4d: ", i);
4082ef84
NC		 11120 if (i >= num_dynamic_syms)
11121 printf (_("<corrupt index>"));
11122 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11123 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11124 else
2b692964 11125 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11126 putchar (' ');
252b5132
RH		 11127
11128 switch (dynamic_syminfo[i].si_boundto)
11129 {
11130 case SYMINFO_BT_SELF:
11131 fputs ("SELF ", stdout);
11132 break;
11133 case SYMINFO_BT_PARENT:
11134 fputs ("PARENT ", stdout);
11135 break;
11136 default:
11137 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11138 && dynamic_syminfo[i].si_boundto < dynamic_nent
11139 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11140 {
d79b3d50 11141 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11142 putchar (' ' );
11143 }
252b5132
RH		 11144 else
11145 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11146 break;
11147 }
11148
11149 if (flags & SYMINFO_FLG_DIRECT)
11150 printf (" DIRECT");
11151 if (flags & SYMINFO_FLG_PASSTHRU)
11152 printf (" PASSTHRU");
11153 if (flags & SYMINFO_FLG_COPY)
11154 printf (" COPY");
11155 if (flags & SYMINFO_FLG_LAZYLOAD)
11156 printf (" LAZYLOAD");
11157
11158 puts ("");
11159 }
11160
11161 return 1;
11162}
11163
cf13d699
NC		 11164/* Check to see if the given reloc needs to be handled in a target specific
11165 manner. If so then process the reloc and return TRUE otherwise return
11166 FALSE. */
09c11c86 11167
cf13d699
NC		 11168static bfd_boolean
11169target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11170 unsigned char * start,
11171 Elf_Internal_Sym * symtab)
252b5132 11172{
cf13d699 11173 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11174
cf13d699 11175 switch (elf_header.e_machine)
252b5132 11176 {
13761a11
NC		 11177 case EM_MSP430:
11178 case EM_MSP430_OLD:
11179 {
11180 static Elf_Internal_Sym * saved_sym = NULL;
11181
11182 switch (reloc_type)
11183 {
11184 case 10: /* R_MSP430_SYM_DIFF */
11185 if (uses_msp430x_relocs ())
11186 break;
11187 case 21: /* R_MSP430X_SYM_DIFF */
11188 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11189 return TRUE;
11190
11191 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11192 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11193 goto handle_sym_diff;
0b4362b0 11194
13761a11
NC		 11195 case 5: /* R_MSP430_16_BYTE */
11196 case 9: /* R_MSP430_8 */
11197 if (uses_msp430x_relocs ())
11198 break;
11199 goto handle_sym_diff;
11200
11201 case 2: /* R_MSP430_ABS16 */
11202 case 15: /* R_MSP430X_ABS16 */
11203 if (! uses_msp430x_relocs ())
11204 break;
11205 goto handle_sym_diff;
0b4362b0 11206
13761a11
NC		 11207 handle_sym_diff:
11208 if (saved_sym != NULL)
11209 {
11210 bfd_vma value;
11211
11212 value = reloc->r_addend
11213 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11214 - saved_sym->st_value);
11215
11216 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11217
11218 saved_sym = NULL;
11219 return TRUE;
11220 }
11221 break;
11222
11223 default:
11224 if (saved_sym != NULL)
071436c6 11225 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11226 break;
11227 }
11228 break;
11229 }
11230
cf13d699
NC		 11231 case EM_MN10300:
11232 case EM_CYGNUS_MN10300:
11233 {
11234 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11235
cf13d699
NC		 11236 switch (reloc_type)
11237 {
11238 case 34: /* R_MN10300_ALIGN */
11239 return TRUE;
11240 case 33: /* R_MN10300_SYM_DIFF */
11241 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11242 return TRUE;
11243 case 1: /* R_MN10300_32 */
11244 case 2: /* R_MN10300_16 */
11245 if (saved_sym != NULL)
11246 {
11247 bfd_vma value;
252b5132 11248
cf13d699
NC		 11249 value = reloc->r_addend
11250 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11251 - saved_sym->st_value);
252b5132 11252
cf13d699 11253 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11254
cf13d699
NC		 11255 saved_sym = NULL;
11256 return TRUE;
11257 }
11258 break;
11259 default:
11260 if (saved_sym != NULL)
071436c6 11261 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11262 break;
11263 }
11264 break;
11265 }
6ff71e76
NC		 11266
11267 case EM_RL78:
11268 {
11269 static bfd_vma saved_sym1 = 0;
11270 static bfd_vma saved_sym2 = 0;
11271 static bfd_vma value;
11272
11273 switch (reloc_type)
11274 {
11275 case 0x80: /* R_RL78_SYM. */
11276 saved_sym1 = saved_sym2;
11277 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11278 saved_sym2 += reloc->r_addend;
11279 return TRUE;
11280
11281 case 0x83: /* R_RL78_OPsub. */
11282 value = saved_sym1 - saved_sym2;
11283 saved_sym2 = saved_sym1 = 0;
11284 return TRUE;
11285 break;
11286
11287 case 0x41: /* R_RL78_ABS32. */
11288 byte_put (start + reloc->r_offset, value, 4);
11289 value = 0;
11290 return TRUE;
11291
11292 case 0x43: /* R_RL78_ABS16. */
11293 byte_put (start + reloc->r_offset, value, 2);
11294 value = 0;
11295 return TRUE;
11296
11297 default:
11298 break;
11299 }
11300 break;
11301 }
252b5132
RH		 11302 }
11303
cf13d699 11304 return FALSE;
252b5132
RH		 11305}
11306
aca88567
NC		 11307/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11308 DWARF debug sections. This is a target specific test. Note - we do not
11309 go through the whole including-target-headers-multiple-times route, (as
11310 we have already done with <elf/h8.h>) because this would become very
11311 messy and even then this function would have to contain target specific
11312 information (the names of the relocs instead of their numeric values).
11313 FIXME: This is not the correct way to solve this problem. The proper way
11314 is to have target specific reloc sizing and typing functions created by
11315 the reloc-macros.h header, in the same way that it already creates the
11316 reloc naming functions. */
11317
11318static bfd_boolean
11319is_32bit_abs_reloc (unsigned int reloc_type)
11320{
11321 switch (elf_header.e_machine)
11322 {
41e92641 11323 case EM_386:
22abe556 11324 case EM_IAMCU:
41e92641 11325 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11326 case EM_68K:
11327 return reloc_type == 1; /* R_68K_32. */
11328 case EM_860:
11329 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11330 case EM_960:
11331 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11332 case EM_AARCH64:
11333 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11334 case EM_ALPHA:
137b6b5f 11335 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11336 case EM_ARC:
11337 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11338 case EM_ARC_COMPACT:
11339 case EM_ARC_COMPACT2:
11340 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11341 case EM_ARM:
11342 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11343 case EM_AVR_OLD:
aca88567
NC		 11344 case EM_AVR:
11345 return reloc_type == 1;
cfb8c092
NC		 11346 case EM_ADAPTEVA_EPIPHANY:
11347 return reloc_type == 3;
aca88567
NC		 11348 case EM_BLACKFIN:
11349 return reloc_type == 0x12; /* R_byte4_data. */
11350 case EM_CRIS:
11351 return reloc_type == 3; /* R_CRIS_32. */
11352 case EM_CR16:
11353 return reloc_type == 3; /* R_CR16_NUM32. */
11354 case EM_CRX:
11355 return reloc_type == 15; /* R_CRX_NUM32. */
11356 case EM_CYGNUS_FRV:
11357 return reloc_type == 1;
41e92641
NC		 11358 case EM_CYGNUS_D10V:
11359 case EM_D10V:
11360 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11361 case EM_CYGNUS_D30V:
11362 case EM_D30V:
11363 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11364 case EM_DLX:
11365 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11366 case EM_CYGNUS_FR30:
11367 case EM_FR30:
11368 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11369 case EM_FT32:
11370 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11371 case EM_H8S:
11372 case EM_H8_300:
11373 case EM_H8_300H:
11374 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11375 case EM_IA_64:
d1c4b12b
NC		 11376 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11377 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11378 case EM_IP2K_OLD:
11379 case EM_IP2K:
11380 return reloc_type == 2; /* R_IP2K_32. */
11381 case EM_IQ2000:
11382 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11383 case EM_LATTICEMICO32:
11384 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11385 case EM_M32C_OLD:
aca88567
NC		 11386 case EM_M32C:
11387 return reloc_type == 3; /* R_M32C_32. */
11388 case EM_M32R:
11389 return reloc_type == 34; /* R_M32R_32_RELA. */
11390 case EM_MCORE:
11391 return reloc_type == 1; /* R_MCORE_ADDR32. */
11392 case EM_CYGNUS_MEP:
11393 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11394 case EM_METAG:
11395 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11396 case EM_MICROBLAZE:
11397 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11398 case EM_MIPS:
11399 return reloc_type == 2; /* R_MIPS_32. */
11400 case EM_MMIX:
11401 return reloc_type == 4; /* R_MMIX_32. */
11402 case EM_CYGNUS_MN10200:
11403 case EM_MN10200:
11404 return reloc_type == 1; /* R_MN10200_32. */
11405 case EM_CYGNUS_MN10300:
11406 case EM_MN10300:
11407 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11408 case EM_MOXIE:
11409 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11410 case EM_MSP430_OLD:
11411 case EM_MSP430:
13761a11 11412 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11413 case EM_MT:
11414 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11415 case EM_NDS32:
11416 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11417 case EM_ALTERA_NIOS2:
36591ba1 11418 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11419 case EM_NIOS32:
11420 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11421 case EM_OR1K:
11422 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11423 case EM_PARISC:
5fda8eca
NC		 11424 return (reloc_type == 1 /* R_PARISC_DIR32. */
11425 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11426 case EM_PJ:
11427 case EM_PJ_OLD:
11428 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11429 case EM_PPC64:
11430 return reloc_type == 1; /* R_PPC64_ADDR32. */
11431 case EM_PPC:
11432 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11433 case EM_RL78:
11434 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11435 case EM_RX:
11436 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11437 case EM_S370:
11438 return reloc_type == 1; /* R_I370_ADDR31. */
11439 case EM_S390_OLD:
11440 case EM_S390:
11441 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11442 case EM_SCORE:
11443 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11444 case EM_SH:
11445 return reloc_type == 1; /* R_SH_DIR32. */
11446 case EM_SPARC32PLUS:
11447 case EM_SPARCV9:
11448 case EM_SPARC:
11449 return reloc_type == 3 /* R_SPARC_32. */
11450 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11451 case EM_SPU:
11452 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11453 case EM_TI_C6000:
11454 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11455 case EM_TILEGX:
11456 return reloc_type == 2; /* R_TILEGX_32. */
11457 case EM_TILEPRO:
11458 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11459 case EM_CYGNUS_V850:
11460 case EM_V850:
11461 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11462 case EM_V800:
11463 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11464 case EM_VAX:
11465 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11466 case EM_VISIUM:
11467 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11468 case EM_X86_64:
8a9036a4 11469 case EM_L1OM:
7a9068fe 11470 case EM_K1OM:
aca88567 11471 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11472 case EM_XC16X:
11473 case EM_C166:
11474 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11475 case EM_XGATE:
11476 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11477 case EM_XSTORMY16:
11478 return reloc_type == 1; /* R_XSTROMY16_32. */
11479 case EM_XTENSA_OLD:
11480 case EM_XTENSA:
11481 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11482 default:
bee0ee85
NC		 11483 {
11484 static unsigned int prev_warn = 0;
11485
11486 /* Avoid repeating the same warning multiple times. */
11487 if (prev_warn != elf_header.e_machine)
11488 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11489 elf_header.e_machine);
11490 prev_warn = elf_header.e_machine;
11491 return FALSE;
11492 }
aca88567
NC		 11493 }
11494}
11495
11496/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11497 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11498
11499static bfd_boolean
11500is_32bit_pcrel_reloc (unsigned int reloc_type)
11501{
11502 switch (elf_header.e_machine)
11503 {
41e92641 11504 case EM_386:
22abe556 11505 case EM_IAMCU:
3e0873ac 11506 return reloc_type == 2; /* R_386_PC32. */
aca88567 11507 case EM_68K:
3e0873ac 11508 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11509 case EM_AARCH64:
11510 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11511 case EM_ADAPTEVA_EPIPHANY:
11512 return reloc_type == 6;
aca88567
NC		 11513 case EM_ALPHA:
11514 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11515 case EM_ARM:
3e0873ac 11516 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11517 case EM_MICROBLAZE:
11518 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11519 case EM_OR1K:
11520 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11521 case EM_PARISC:
85acf597 11522 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11523 case EM_PPC:
11524 return reloc_type == 26; /* R_PPC_REL32. */
11525 case EM_PPC64:
3e0873ac 11526 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11527 case EM_S390_OLD:
11528 case EM_S390:
3e0873ac 11529 return reloc_type == 5; /* R_390_PC32. */
aca88567 11530 case EM_SH:
3e0873ac 11531 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11532 case EM_SPARC32PLUS:
11533 case EM_SPARCV9:
11534 case EM_SPARC:
3e0873ac 11535 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11536 case EM_SPU:
11537 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11538 case EM_TILEGX:
11539 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11540 case EM_TILEPRO:
11541 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11542 case EM_VISIUM:
11543 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11544 case EM_X86_64:
8a9036a4 11545 case EM_L1OM:
7a9068fe 11546 case EM_K1OM:
3e0873ac 11547 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11548 case EM_XTENSA_OLD:
11549 case EM_XTENSA:
11550 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11551 default:
11552 /* Do not abort or issue an error message here. Not all targets use
11553 pc-relative 32-bit relocs in their DWARF debug information and we
11554 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11555 more helpful warning message will be generated by apply_relocations
11556 anyway, so just return. */
aca88567
NC		 11557 return FALSE;
11558 }
11559}
11560
11561/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11562 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11563
11564static bfd_boolean
11565is_64bit_abs_reloc (unsigned int reloc_type)
11566{
11567 switch (elf_header.e_machine)
11568 {
a06ea964
NC		 11569 case EM_AARCH64:
11570 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11571 case EM_ALPHA:
11572 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11573 case EM_IA_64:
11574 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11575 case EM_PARISC:
11576 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11577 case EM_PPC64:
11578 return reloc_type == 38; /* R_PPC64_ADDR64. */
11579 case EM_SPARC32PLUS:
11580 case EM_SPARCV9:
11581 case EM_SPARC:
11582 return reloc_type == 54; /* R_SPARC_UA64. */
11583 case EM_X86_64:
8a9036a4 11584 case EM_L1OM:
7a9068fe 11585 case EM_K1OM:
aca88567 11586 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11587 case EM_S390_OLD:
11588 case EM_S390:
aa137e4d
NC		 11589 return reloc_type == 22; /* R_S390_64. */
11590 case EM_TILEGX:
11591 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11592 case EM_MIPS:
aa137e4d 11593 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11594 default:
11595 return FALSE;
11596 }
11597}
11598
85acf597
RH		 11599/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11600 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11601
11602static bfd_boolean
11603is_64bit_pcrel_reloc (unsigned int reloc_type)
11604{
11605 switch (elf_header.e_machine)
11606 {
a06ea964
NC		 11607 case EM_AARCH64:
11608 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11609 case EM_ALPHA:
aa137e4d 11610 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11611 case EM_IA_64:
aa137e4d 11612 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11613 case EM_PARISC:
aa137e4d 11614 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11615 case EM_PPC64:
aa137e4d 11616 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11617 case EM_SPARC32PLUS:
11618 case EM_SPARCV9:
11619 case EM_SPARC:
aa137e4d 11620 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11621 case EM_X86_64:
8a9036a4 11622 case EM_L1OM:
7a9068fe 11623 case EM_K1OM:
aa137e4d 11624 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11625 case EM_S390_OLD:
11626 case EM_S390:
aa137e4d
NC		 11627 return reloc_type == 23; /* R_S390_PC64. */
11628 case EM_TILEGX:
11629 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11630 default:
11631 return FALSE;
11632 }
11633}
11634
4dc3c23d
AM		 11635/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11636 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11637
11638static bfd_boolean
11639is_24bit_abs_reloc (unsigned int reloc_type)
11640{
11641 switch (elf_header.e_machine)
11642 {
11643 case EM_CYGNUS_MN10200:
11644 case EM_MN10200:
11645 return reloc_type == 4; /* R_MN10200_24. */
11646 default:
11647 return FALSE;
11648 }
11649}
11650
aca88567
NC		 11651/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11652 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11653
11654static bfd_boolean
11655is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11656{
11657 switch (elf_header.e_machine)
11658 {
886a2506
NC		 11659 case EM_ARC:
11660 case EM_ARC_COMPACT:
11661 case EM_ARC_COMPACT2:
11662 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11663 case EM_AVR_OLD:
11664 case EM_AVR:
11665 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11666 case EM_ADAPTEVA_EPIPHANY:
11667 return reloc_type == 5;
41e92641
NC		 11668 case EM_CYGNUS_D10V:
11669 case EM_D10V:
11670 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11671 case EM_H8S:
11672 case EM_H8_300:
11673 case EM_H8_300H:
aca88567
NC		 11674 return reloc_type == R_H8_DIR16;
11675 case EM_IP2K_OLD:
11676 case EM_IP2K:
11677 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11678 case EM_M32C_OLD:
f4236fe4
DD		 11679 case EM_M32C:
11680 return reloc_type == 1; /* R_M32C_16 */
aca88567 11681 case EM_MSP430:
13761a11
NC		 11682 if (uses_msp430x_relocs ())
11683 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11684 case EM_MSP430_OLD:
aca88567 11685 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11686 case EM_NDS32:
11687 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11688 case EM_ALTERA_NIOS2:
36591ba1 11689 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11690 case EM_NIOS32:
11691 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11692 case EM_OR1K:
11693 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11694 case EM_TI_C6000:
11695 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11696 case EM_XC16X:
11697 case EM_C166:
11698 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11699 case EM_CYGNUS_MN10200:
11700 case EM_MN10200:
11701 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11702 case EM_CYGNUS_MN10300:
11703 case EM_MN10300:
11704 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11705 case EM_VISIUM:
11706 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11707 case EM_XGATE:
11708 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11709 default:
aca88567 11710 return FALSE;
4b78141a
NC		 11711 }
11712}
11713
2a7b2e88
JK		 11714/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11715 relocation entries (possibly formerly used for SHT_GROUP sections). */
11716
11717static bfd_boolean
11718is_none_reloc (unsigned int reloc_type)
11719{
11720 switch (elf_header.e_machine)
11721 {
cb8f3167
NC		 11722 case EM_68K: /* R_68K_NONE. */
11723 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11724 case EM_SPARC32PLUS:
11725 case EM_SPARCV9:
cb8f3167
NC		 11726 case EM_SPARC: /* R_SPARC_NONE. */
11727 case EM_MIPS: /* R_MIPS_NONE. */
11728 case EM_PARISC: /* R_PARISC_NONE. */
11729 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11730 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11731 case EM_PPC: /* R_PPC_NONE. */
11732 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11733 case EM_ARC: /* R_ARC_NONE. */
11734 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11735 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11736 case EM_ARM: /* R_ARM_NONE. */
11737 case EM_IA_64: /* R_IA64_NONE. */
11738 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11739 case EM_S390_OLD:
cb8f3167
NC		 11740 case EM_S390: /* R_390_NONE. */
11741 case EM_CRIS: /* R_CRIS_NONE. */
11742 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11743 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11744 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11745 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11746 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11747 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11748 case EM_M32R: /* R_M32R_NONE. */
40b36596 11749 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11750 case EM_TILEGX: /* R_TILEGX_NONE. */
11751 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11752 case EM_XC16X:
11753 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11754 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11755 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11756 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11757 return reloc_type == 0;
a06ea964
NC		 11758 case EM_AARCH64:
11759 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11760 case EM_NDS32:
11761 return (reloc_type == 0 /* R_XTENSA_NONE. */
11762 || reloc_type == 204 /* R_NDS32_DIFF8. */
11763 || reloc_type == 205 /* R_NDS32_DIFF16. */
11764 || reloc_type == 206 /* R_NDS32_DIFF32. */
11765 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11766 case EM_XTENSA_OLD:
11767 case EM_XTENSA:
4dc3c23d
AM		 11768 return (reloc_type == 0 /* R_XTENSA_NONE. */
11769 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11770 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11771 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11772 case EM_METAG:
11773 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11774 }
11775 return FALSE;
11776}
11777
d1c4b12b
NC		 11778/* Returns TRUE if there is a relocation against
11779 section NAME at OFFSET bytes. */
11780
11781bfd_boolean
11782reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11783{
11784 Elf_Internal_Rela * relocs;
11785 Elf_Internal_Rela * rp;
11786
11787 if (dsec == NULL || dsec->reloc_info == NULL)
11788 return FALSE;
11789
11790 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11791
11792 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11793 if (rp->r_offset == offset)
11794 return TRUE;
11795
11796 return FALSE;
11797}
11798
cf13d699
NC		 11799/* Apply relocations to a section.
11800 Note: So far support has been added only for those relocations
11801 which can be found in debug sections.
d1c4b12b
NC		 11802 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11803 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11804 FIXME: Add support for more relocations ? */
1b315056 11805
cf13d699 11806static void
d1c4b12b
NC		 11807apply_relocations (void * file,
11808 const Elf_Internal_Shdr * section,
11809 unsigned char * start,
11810 bfd_size_type size,
11811 void ** relocs_return,
11812 unsigned long * num_relocs_return)
1b315056 11813{
cf13d699 11814 Elf_Internal_Shdr * relsec;
0d2a7a93 11815 unsigned char * end = start + size;
cb8f3167 11816
d1c4b12b
NC		 11817 if (relocs_return != NULL)
11818 {
11819 * (Elf_Internal_Rela **) relocs_return = NULL;
11820 * num_relocs_return = 0;
11821 }
11822
cf13d699
NC		 11823 if (elf_header.e_type != ET_REL)
11824 return;
1b315056 11825
cf13d699 11826 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11827 for (relsec = section_headers;
11828 relsec < section_headers + elf_header.e_shnum;
11829 ++relsec)
252b5132 11830 {
41e92641
NC		 11831 bfd_boolean is_rela;
11832 unsigned long num_relocs;
2cf0635d
NC		 11833 Elf_Internal_Rela * relocs;
11834 Elf_Internal_Rela * rp;
11835 Elf_Internal_Shdr * symsec;
11836 Elf_Internal_Sym * symtab;
ba5cdace 11837 unsigned long num_syms;
2cf0635d 11838 Elf_Internal_Sym * sym;
252b5132 11839
41e92641 11840 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11841 || relsec->sh_info >= elf_header.e_shnum
11842 || section_headers + relsec->sh_info != section
c256ffe7 11843 || relsec->sh_size == 0
4fbb74a6 11844 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11845 continue;
428409d5 11846
41e92641
NC		 11847 is_rela = relsec->sh_type == SHT_RELA;
11848
11849 if (is_rela)
11850 {
3f5e193b
NC		 11851 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11852 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11853 return;
11854 }
11855 else
11856 {
3f5e193b
NC		 11857 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11858 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11859 return;
11860 }
11861
11862 /* SH uses RELA but uses in place value instead of the addend field. */
11863 if (elf_header.e_machine == EM_SH)
11864 is_rela = FALSE;
428409d5 11865
4fbb74a6 11866 symsec = section_headers + relsec->sh_link;
ba5cdace 11867 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11868
41e92641 11869 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11870 {
41e92641
NC		 11871 bfd_vma addend;
11872 unsigned int reloc_type;
11873 unsigned int reloc_size;
91d6fa6a 11874 unsigned char * rloc;
ba5cdace 11875 unsigned long sym_index;
4b78141a 11876
aca88567 11877 reloc_type = get_reloc_type (rp->r_info);
41e92641 11878
98fb390a 11879 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11880 continue;
98fb390a
NC		 11881 else if (is_none_reloc (reloc_type))
11882 continue;
11883 else if (is_32bit_abs_reloc (reloc_type)
11884 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11885 reloc_size = 4;
85acf597
RH		 11886 else if (is_64bit_abs_reloc (reloc_type)
11887 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11888 reloc_size = 8;
4dc3c23d
AM		 11889 else if (is_24bit_abs_reloc (reloc_type))
11890 reloc_size = 3;
aca88567
NC		 11891 else if (is_16bit_abs_reloc (reloc_type))
11892 reloc_size = 2;
11893 else
4b78141a 11894 {
bee0ee85
NC		 11895 static unsigned int prev_reloc = 0;
11896 if (reloc_type != prev_reloc)
11897 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11898 reloc_type, printable_section_name (section));
11899 prev_reloc = reloc_type;
4b78141a
NC		 11900 continue;
11901 }
103f02d3 11902
91d6fa6a 11903 rloc = start + rp->r_offset;
c8da6823 11904 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11905 {
11906 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11907 (unsigned long) rp->r_offset,
74e1a04b 11908 printable_section_name (section));
700dd8b7
L		 11909 continue;
11910 }
103f02d3 11911
ba5cdace
NC		 11912 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11913 if (sym_index >= num_syms)
11914 {
11915 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11916 sym_index, printable_section_name (section));
ba5cdace
NC		 11917 continue;
11918 }
11919 sym = symtab + sym_index;
41e92641
NC		 11920
11921 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11922 make sure that it is of an appropriate type.
11923
11924 Relocations against symbols without type can happen.
11925 Gcc -feliminate-dwarf2-dups may generate symbols
11926 without type for debug info.
11927
11928 Icc generates relocations against function symbols
11929 instead of local labels.
11930
11931 Relocations against object symbols can happen, eg when
11932 referencing a global array. For an example of this see
11933 the _clz.o binary in libgcc.a. */
aca88567 11934 if (sym != symtab
55f25fc3 11935 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11936 {
41e92641 11937 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11938 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11939 (long int)(rp - relocs),
74e1a04b 11940 printable_section_name (relsec));
aca88567 11941 continue;
5b18a4bc 11942 }
252b5132 11943
4dc3c23d
AM		 11944 addend = 0;
11945 if (is_rela)
11946 addend += rp->r_addend;
c47320c3
AM		 11947 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11948 partial_inplace. */
4dc3c23d
AM		 11949 if (!is_rela
11950 || (elf_header.e_machine == EM_XTENSA
11951 && reloc_type == 1)
11952 || ((elf_header.e_machine == EM_PJ
11953 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11954 && reloc_type == 1)
11955 || ((elf_header.e_machine == EM_D30V
11956 || elf_header.e_machine == EM_CYGNUS_D30V)
11957 && reloc_type == 12))
91d6fa6a 11958 addend += byte_get (rloc, reloc_size);
cb8f3167 11959
85acf597
RH		 11960 if (is_32bit_pcrel_reloc (reloc_type)
11961 || is_64bit_pcrel_reloc (reloc_type))
11962 {
11963 /* On HPPA, all pc-relative relocations are biased by 8. */
11964 if (elf_header.e_machine == EM_PARISC)
11965 addend -= 8;
91d6fa6a 11966 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11967 reloc_size);
11968 }
41e92641 11969 else
91d6fa6a 11970 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11971 }
252b5132 11972
5b18a4bc 11973 free (symtab);
d1c4b12b
NC		 11974
11975 if (relocs_return)
11976 {
11977 * (Elf_Internal_Rela **) relocs_return = relocs;
11978 * num_relocs_return = num_relocs;
11979 }
11980 else
11981 free (relocs);
11982
5b18a4bc
NC		 11983 break;
11984 }
5b18a4bc 11985}
103f02d3 11986
cf13d699
NC		 11987#ifdef SUPPORT_DISASSEMBLY
11988static int
11989disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11990{
74e1a04b 11991 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11992
74e1a04b 11993 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11994
11995 return 1;
11996}
11997#endif
11998
11999/* Reads in the contents of SECTION from FILE, returning a pointer
12000 to a malloc'ed buffer or NULL if something went wrong. */
12001
12002static char *
12003get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12004{
12005 bfd_size_type num_bytes;
12006
12007 num_bytes = section->sh_size;
12008
12009 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12010 {
12011 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12012 printable_section_name (section));
cf13d699
NC		 12013 return NULL;
12014 }
12015
3f5e193b
NC		 12016 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12017 _("section contents"));
cf13d699
NC		 12018}
12019
0e602686
NC		 12020/* Uncompresses a section that was compressed using zlib, in place. */
12021
12022static bfd_boolean
12023uncompress_section_contents (unsigned char **buffer,
12024 dwarf_size_type uncompressed_size,
12025 dwarf_size_type *size)
12026{
12027 dwarf_size_type compressed_size = *size;
12028 unsigned char * compressed_buffer = *buffer;
12029 unsigned char * uncompressed_buffer;
12030 z_stream strm;
12031 int rc;
12032
12033 /* It is possible the section consists of several compressed
12034 buffers concatenated together, so we uncompress in a loop. */
12035 /* PR 18313: The state field in the z_stream structure is supposed
12036 to be invisible to the user (ie us), but some compilers will
12037 still complain about it being used without initialisation. So
12038 we first zero the entire z_stream structure and then set the fields
12039 that we need. */
12040 memset (& strm, 0, sizeof strm);
12041 strm.avail_in = compressed_size;
12042 strm.next_in = (Bytef *) compressed_buffer;
12043 strm.avail_out = uncompressed_size;
12044 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12045
12046 rc = inflateInit (& strm);
12047 while (strm.avail_in > 0)
12048 {
12049 if (rc != Z_OK)
12050 goto fail;
12051 strm.next_out = ((Bytef *) uncompressed_buffer
12052 + (uncompressed_size - strm.avail_out));
12053 rc = inflate (&strm, Z_FINISH);
12054 if (rc != Z_STREAM_END)
12055 goto fail;
12056 rc = inflateReset (& strm);
12057 }
12058 rc = inflateEnd (& strm);
12059 if (rc != Z_OK
12060 || strm.avail_out != 0)
12061 goto fail;
12062
12063 *buffer = uncompressed_buffer;
12064 *size = uncompressed_size;
12065 return TRUE;
12066
12067 fail:
12068 free (uncompressed_buffer);
12069 /* Indicate decompression failure. */
12070 *buffer = NULL;
12071 return FALSE;
12072}
dd24e3da 12073
cf13d699
NC		 12074static void
12075dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12076{
0e602686
NC		 12077 Elf_Internal_Shdr * relsec;
12078 bfd_size_type num_bytes;
fd8008d8
L		 12079 unsigned char * data;
12080 unsigned char * end;
12081 unsigned char * real_start;
12082 unsigned char * start;
0e602686 12083 bfd_boolean some_strings_shown;
cf13d699 12084
fd8008d8
L		 12085 real_start = start = (unsigned char *) get_section_contents (section,
12086 file);
cf13d699
NC		 12087 if (start == NULL)
12088 return;
0e602686 12089 num_bytes = section->sh_size;
cf13d699 12090
74e1a04b 12091 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12092
0e602686
NC		 12093 if (decompress_dumps)
12094 {
12095 dwarf_size_type new_size = num_bytes;
12096 dwarf_size_type uncompressed_size = 0;
12097
12098 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12099 {
12100 Elf_Internal_Chdr chdr;
12101 unsigned int compression_header_size
12102 = get_compression_header (& chdr, (unsigned char *) start);
12103
813dabb9 12104 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12105 {
813dabb9
L		 12106 warn (_("section '%s' has unsupported compress type: %d\n"),
12107 printable_section_name (section), chdr.ch_type);
12108 return;
12109 }
12110 else if (chdr.ch_addralign != section->sh_addralign)
12111 {
12112 warn (_("compressed section '%s' is corrupted\n"),
12113 printable_section_name (section));
12114 return;
0e602686 12115 }
813dabb9
L		 12116 uncompressed_size = chdr.ch_size;
12117 start += compression_header_size;
12118 new_size -= compression_header_size;
0e602686
NC		 12119 }
12120 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12121 {
12122 /* Read the zlib header. In this case, it should be "ZLIB"
12123 followed by the uncompressed section size, 8 bytes in
12124 big-endian order. */
12125 uncompressed_size = start[4]; uncompressed_size <<= 8;
12126 uncompressed_size += start[5]; uncompressed_size <<= 8;
12127 uncompressed_size += start[6]; uncompressed_size <<= 8;
12128 uncompressed_size += start[7]; uncompressed_size <<= 8;
12129 uncompressed_size += start[8]; uncompressed_size <<= 8;
12130 uncompressed_size += start[9]; uncompressed_size <<= 8;
12131 uncompressed_size += start[10]; uncompressed_size <<= 8;
12132 uncompressed_size += start[11];
12133 start += 12;
12134 new_size -= 12;
12135 }
12136
12137 if (uncompressed_size
fd8008d8 12138 && uncompress_section_contents (& start,
0e602686
NC		 12139 uncompressed_size, & new_size))
12140 num_bytes = new_size;
12141 }
fd8008d8 12142
cf13d699
NC		 12143 /* If the section being dumped has relocations against it the user might
12144 be expecting these relocations to have been applied. Check for this
12145 case and issue a warning message in order to avoid confusion.
12146 FIXME: Maybe we ought to have an option that dumps a section with
12147 relocs applied ? */
12148 for (relsec = section_headers;
12149 relsec < section_headers + elf_header.e_shnum;
12150 ++relsec)
12151 {
12152 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12153 || relsec->sh_info >= elf_header.e_shnum
12154 || section_headers + relsec->sh_info != section
12155 || relsec->sh_size == 0
12156 || relsec->sh_link >= elf_header.e_shnum)
12157 continue;
12158
12159 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12160 break;
12161 }
12162
cf13d699
NC		 12163 data = start;
12164 end = start + num_bytes;
12165 some_strings_shown = FALSE;
12166
12167 while (data < end)
12168 {
12169 while (!ISPRINT (* data))
12170 if (++ data >= end)
12171 break;
12172
12173 if (data < end)
12174 {
071436c6
NC		 12175 size_t maxlen = end - data;
12176
cf13d699 12177#ifndef __MSVCRT__
c975cc98
NC		 12178 /* PR 11128: Use two separate invocations in order to work
12179 around bugs in the Solaris 8 implementation of printf. */
12180 printf (" [%6tx] ", data - start);
cf13d699 12181#else
071436c6 12182 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12183#endif
4082ef84
NC		 12184 if (maxlen > 0)
12185 {
fd8008d8 12186 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12187 putchar ('\n');
fd8008d8 12188 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12189 }
12190 else
12191 {
12192 printf (_("<corrupt>\n"));
12193 data = end;
12194 }
cf13d699
NC		 12195 some_strings_shown = TRUE;
12196 }
12197 }
12198
12199 if (! some_strings_shown)
12200 printf (_(" No strings found in this section."));
12201
0e602686 12202 free (real_start);
cf13d699
NC		 12203
12204 putchar ('\n');
12205}
12206
12207static void
12208dump_section_as_bytes (Elf_Internal_Shdr * section,
12209 FILE * file,
12210 bfd_boolean relocate)
12211{
12212 Elf_Internal_Shdr * relsec;
0e602686
NC		 12213 bfd_size_type bytes;
12214 bfd_size_type section_size;
12215 bfd_vma addr;
12216 unsigned char * data;
12217 unsigned char * real_start;
12218 unsigned char * start;
12219
12220 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12221 if (start == NULL)
12222 return;
0e602686 12223 section_size = section->sh_size;
cf13d699 12224
74e1a04b 12225 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12226
0e602686
NC		 12227 if (decompress_dumps)
12228 {
12229 dwarf_size_type new_size = section_size;
12230 dwarf_size_type uncompressed_size = 0;
12231
12232 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12233 {
12234 Elf_Internal_Chdr chdr;
12235 unsigned int compression_header_size
12236 = get_compression_header (& chdr, start);
12237
813dabb9 12238 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12239 {
813dabb9
L		 12240 warn (_("section '%s' has unsupported compress type: %d\n"),
12241 printable_section_name (section), chdr.ch_type);
12242 return;
0e602686 12243 }
813dabb9
L		 12244 else if (chdr.ch_addralign != section->sh_addralign)
12245 {
12246 warn (_("compressed section '%s' is corrupted\n"),
12247 printable_section_name (section));
12248 return;
12249 }
12250 uncompressed_size = chdr.ch_size;
12251 start += compression_header_size;
12252 new_size -= compression_header_size;
0e602686
NC		 12253 }
12254 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12255 {
12256 /* Read the zlib header. In this case, it should be "ZLIB"
12257 followed by the uncompressed section size, 8 bytes in
12258 big-endian order. */
12259 uncompressed_size = start[4]; uncompressed_size <<= 8;
12260 uncompressed_size += start[5]; uncompressed_size <<= 8;
12261 uncompressed_size += start[6]; uncompressed_size <<= 8;
12262 uncompressed_size += start[7]; uncompressed_size <<= 8;
12263 uncompressed_size += start[8]; uncompressed_size <<= 8;
12264 uncompressed_size += start[9]; uncompressed_size <<= 8;
12265 uncompressed_size += start[10]; uncompressed_size <<= 8;
12266 uncompressed_size += start[11];
12267 start += 12;
12268 new_size -= 12;
12269 }
12270
12271 if (uncompressed_size
12272 && uncompress_section_contents (& start, uncompressed_size,
12273 & new_size))
12274 section_size = new_size;
12275 }
14ae95f2 12276
cf13d699
NC		 12277 if (relocate)
12278 {
0e602686 12279 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12280 }
12281 else
12282 {
12283 /* If the section being dumped has relocations against it the user might
12284 be expecting these relocations to have been applied. Check for this
12285 case and issue a warning message in order to avoid confusion.
12286 FIXME: Maybe we ought to have an option that dumps a section with
12287 relocs applied ? */
12288 for (relsec = section_headers;
12289 relsec < section_headers + elf_header.e_shnum;
12290 ++relsec)
12291 {
12292 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12293 || relsec->sh_info >= elf_header.e_shnum
12294 || section_headers + relsec->sh_info != section
12295 || relsec->sh_size == 0
12296 || relsec->sh_link >= elf_header.e_shnum)
12297 continue;
12298
12299 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12300 break;
12301 }
12302 }
12303
12304 addr = section->sh_addr;
0e602686 12305 bytes = section_size;
cf13d699
NC		 12306 data = start;
12307
12308 while (bytes)
12309 {
12310 int j;
12311 int k;
12312 int lbytes;
12313
12314 lbytes = (bytes > 16 ? 16 : bytes);
12315
12316 printf (" 0x%8.8lx ", (unsigned long) addr);
12317
12318 for (j = 0; j < 16; j++)
12319 {
12320 if (j < lbytes)
12321 printf ("%2.2x", data[j]);
12322 else
12323 printf (" ");
12324
12325 if ((j & 3) == 3)
12326 printf (" ");
12327 }
12328
12329 for (j = 0; j < lbytes; j++)
12330 {
12331 k = data[j];
12332 if (k >= ' ' && k < 0x7f)
12333 printf ("%c", k);
12334 else
12335 printf (".");
12336 }
12337
12338 putchar ('\n');
12339
12340 data += lbytes;
12341 addr += lbytes;
12342 bytes -= lbytes;
12343 }
12344
0e602686 12345 free (real_start);
cf13d699
NC		 12346
12347 putchar ('\n');
12348}
12349
d966045b
DJ		 12350static int
12351load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12352 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12353{
2cf0635d 12354 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12355 char buf [64];
1007acb3 12356
19e6b90e
L		 12357 /* If it is already loaded, do nothing. */
12358 if (section->start != NULL)
12359 return 1;
1007acb3 12360
19e6b90e
L		 12361 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12362 section->address = sec->sh_addr;
06614111 12363 section->user_data = NULL;
3f5e193b
NC		 12364 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12365 sec->sh_offset, 1,
12366 sec->sh_size, buf);
59245841
NC		 12367 if (section->start == NULL)
12368 section->size = 0;
12369 else
12370 {
77115a4a
L		 12371 unsigned char *start = section->start;
12372 dwarf_size_type size = sec->sh_size;
dab394de 12373 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12374
12375 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12376 {
12377 Elf_Internal_Chdr chdr;
12378 unsigned int compression_header_size
12379 = get_compression_header (&chdr, start);
813dabb9
L		 12380 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12381 {
12382 warn (_("section '%s' has unsupported compress type: %d\n"),
12383 section->name, chdr.ch_type);
12384 return 0;
12385 }
12386 else if (chdr.ch_addralign != sec->sh_addralign)
12387 {
12388 warn (_("compressed section '%s' is corrupted\n"),
12389 section->name);
12390 return 0;
12391 }
dab394de 12392 uncompressed_size = chdr.ch_size;
77115a4a
L		 12393 start += compression_header_size;
12394 size -= compression_header_size;
12395 }
dab394de
L		 12396 else if (size > 12 && streq ((char *) start, "ZLIB"))
12397 {
12398 /* Read the zlib header. In this case, it should be "ZLIB"
12399 followed by the uncompressed section size, 8 bytes in
12400 big-endian order. */
12401 uncompressed_size = start[4]; uncompressed_size <<= 8;
12402 uncompressed_size += start[5]; uncompressed_size <<= 8;
12403 uncompressed_size += start[6]; uncompressed_size <<= 8;
12404 uncompressed_size += start[7]; uncompressed_size <<= 8;
12405 uncompressed_size += start[8]; uncompressed_size <<= 8;
12406 uncompressed_size += start[9]; uncompressed_size <<= 8;
12407 uncompressed_size += start[10]; uncompressed_size <<= 8;
12408 uncompressed_size += start[11];
12409 start += 12;
12410 size -= 12;
12411 }
12412
12413 if (uncompressed_size
12414 && uncompress_section_contents (&start, uncompressed_size,
12415 &size))
77115a4a
L		 12416 {
12417 /* Free the compressed buffer, update the section buffer
12418 and the section size if uncompress is successful. */
12419 free (section->start);
12420 section->start = start;
77115a4a
L		 12421 }
12422 section->size = size;
59245841 12423 }
4a114e3e 12424
1b315056
CS		 12425 if (section->start == NULL)
12426 return 0;
12427
19e6b90e 12428 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12429 apply_relocations ((FILE *) file, sec, section->start, section->size,
12430 & section->reloc_info, & section->num_relocs);
12431 else
12432 {
12433 section->reloc_info = NULL;
12434 section->num_relocs = 0;
12435 }
1007acb3 12436
1b315056 12437 return 1;
1007acb3
L		 12438}
12439
657d0d47
CC		 12440/* If this is not NULL, load_debug_section will only look for sections
12441 within the list of sections given here. */
12442unsigned int *section_subset = NULL;
12443
d966045b 12444int
2cf0635d 12445load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12446{
2cf0635d
NC		 12447 struct dwarf_section * section = &debug_displays [debug].section;
12448 Elf_Internal_Shdr * sec;
d966045b
DJ		 12449
12450 /* Locate the debug section. */
657d0d47 12451 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12452 if (sec != NULL)
12453 section->name = section->uncompressed_name;
12454 else
12455 {
657d0d47 12456 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12457 if (sec != NULL)
12458 section->name = section->compressed_name;
12459 }
12460 if (sec == NULL)
12461 return 0;
12462
657d0d47
CC		 12463 /* If we're loading from a subset of sections, and we've loaded
12464 a section matching this name before, it's likely that it's a
12465 different one. */
12466 if (section_subset != NULL)
12467 free_debug_section (debug);
12468
3f5e193b 12469 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12470}
12471
19e6b90e
L		 12472void
12473free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12474{
2cf0635d 12475 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12476
19e6b90e
L		 12477 if (section->start == NULL)
12478 return;
1007acb3 12479
19e6b90e
L		 12480 free ((char *) section->start);
12481 section->start = NULL;
12482 section->address = 0;
12483 section->size = 0;
1007acb3
L		 12484}
12485
1007acb3 12486static int
657d0d47 12487display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12488{
2cf0635d 12489 char * name = SECTION_NAME (section);
74e1a04b 12490 const char * print_name = printable_section_name (section);
19e6b90e
L		 12491 bfd_size_type length;
12492 int result = 1;
3f5e193b 12493 int i;
1007acb3 12494
19e6b90e
L		 12495 length = section->sh_size;
12496 if (length == 0)
1007acb3 12497 {
74e1a04b 12498 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12499 return 0;
1007acb3 12500 }
5dff79d8
NC		 12501 if (section->sh_type == SHT_NOBITS)
12502 {
12503 /* There is no point in dumping the contents of a debugging section
12504 which has the NOBITS type - the bits in the file will be random.
12505 This can happen when a file containing a .eh_frame section is
12506 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12507 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12508 print_name);
5dff79d8
NC		 12509 return 0;
12510 }
1007acb3 12511
0112cd26 12512 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12513 name = ".debug_info";
1007acb3 12514
19e6b90e
L		 12515 /* See if we know how to display the contents of this section. */
12516 for (i = 0; i < max; i++)
1b315056 12517 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12518 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12519 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12520 {
2cf0635d 12521 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12522 int secondary = (section != find_section (name));
12523
12524 if (secondary)
3f5e193b 12525 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12526
b40bf0a2
NC		 12527 if (i == line && const_strneq (name, ".debug_line."))
12528 sec->name = name;
12529 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12530 sec->name = sec->uncompressed_name;
12531 else
12532 sec->name = sec->compressed_name;
3f5e193b
NC		 12533 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12534 section, file))
19e6b90e 12535 {
657d0d47
CC		 12536 /* If this debug section is part of a CU/TU set in a .dwp file,
12537 restrict load_debug_section to the sections in that set. */
12538 section_subset = find_cu_tu_set (file, shndx);
12539
19e6b90e 12540 result &= debug_displays[i].display (sec, file);
1007acb3 12541
657d0d47
CC		 12542 section_subset = NULL;
12543
d966045b 12544 if (secondary || (i != info && i != abbrev))
3f5e193b 12545 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12546 }
1007acb3 12547
19e6b90e
L		 12548 break;
12549 }
1007acb3 12550
19e6b90e 12551 if (i == max)
1007acb3 12552 {
74e1a04b 12553 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12554 result = 0;
1007acb3
L		 12555 }
12556
19e6b90e 12557 return result;
5b18a4bc 12558}
103f02d3 12559
aef1f6d0
DJ		 12560/* Set DUMP_SECTS for all sections where dumps were requested
12561 based on section name. */
12562
12563static void
12564initialise_dumps_byname (void)
12565{
2cf0635d 12566 struct dump_list_entry * cur;
aef1f6d0
DJ		 12567
12568 for (cur = dump_sects_byname; cur; cur = cur->next)
12569 {
12570 unsigned int i;
12571 int any;
12572
12573 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12574 if (streq (SECTION_NAME (section_headers + i), cur->name))
12575 {
09c11c86 12576 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12577 any = 1;
12578 }
12579
12580 if (!any)
12581 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12582 cur->name);
12583 }
12584}
12585
5b18a4bc 12586static void
2cf0635d 12587process_section_contents (FILE * file)
5b18a4bc 12588{
2cf0635d 12589 Elf_Internal_Shdr * section;
19e6b90e 12590 unsigned int i;
103f02d3 12591
19e6b90e
L		 12592 if (! do_dump)
12593 return;
103f02d3 12594
aef1f6d0
DJ		 12595 initialise_dumps_byname ();
12596
19e6b90e
L		 12597 for (i = 0, section = section_headers;
12598 i < elf_header.e_shnum && i < num_dump_sects;
12599 i++, section++)
12600 {
12601#ifdef SUPPORT_DISASSEMBLY
12602 if (dump_sects[i] & DISASS_DUMP)
12603 disassemble_section (section, file);
12604#endif
12605 if (dump_sects[i] & HEX_DUMP)
cf13d699 12606 dump_section_as_bytes (section, file, FALSE);
103f02d3 12607
cf13d699
NC		 12608 if (dump_sects[i] & RELOC_DUMP)
12609 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12610
12611 if (dump_sects[i] & STRING_DUMP)
12612 dump_section_as_strings (section, file);
cf13d699
NC		 12613
12614 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12615 display_debug_section (i, section, file);
5b18a4bc 12616 }
103f02d3 12617
19e6b90e
L		 12618 /* Check to see if the user requested a
12619 dump of a section that does not exist. */
12620 while (i++ < num_dump_sects)
12621 if (dump_sects[i])
12622 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12623}
103f02d3 12624
5b18a4bc 12625static void
19e6b90e 12626process_mips_fpe_exception (int mask)
5b18a4bc 12627{
19e6b90e
L		 12628 if (mask)
12629 {
12630 int first = 1;
12631 if (mask & OEX_FPU_INEX)
12632 fputs ("INEX", stdout), first = 0;
12633 if (mask & OEX_FPU_UFLO)
12634 printf ("%sUFLO", first ? "" : "|"), first = 0;
12635 if (mask & OEX_FPU_OFLO)
12636 printf ("%sOFLO", first ? "" : "|"), first = 0;
12637 if (mask & OEX_FPU_DIV0)
12638 printf ("%sDIV0", first ? "" : "|"), first = 0;
12639 if (mask & OEX_FPU_INVAL)
12640 printf ("%sINVAL", first ? "" : "|");
12641 }
5b18a4bc 12642 else
19e6b90e 12643 fputs ("0", stdout);
5b18a4bc 12644}
103f02d3 12645
f6f0e17b
NC		 12646/* Display's the value of TAG at location P. If TAG is
12647 greater than 0 it is assumed to be an unknown tag, and
12648 a message is printed to this effect. Otherwise it is
12649 assumed that a message has already been printed.
12650
12651 If the bottom bit of TAG is set it assumed to have a
12652 string value, otherwise it is assumed to have an integer
12653 value.
12654
12655 Returns an updated P pointing to the first unread byte
12656 beyond the end of TAG's value.
12657
12658 Reads at or beyond END will not be made. */
12659
12660static unsigned char *
12661display_tag_value (int tag,
12662 unsigned char * p,
12663 const unsigned char * const end)
12664{
12665 unsigned long val;
12666
12667 if (tag > 0)
12668 printf (" Tag_unknown_%d: ", tag);
12669
12670 if (p >= end)
12671 {
4082ef84 12672 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12673 }
12674 else if (tag & 1)
12675 {
071436c6
NC		 12676 /* PR 17531 file: 027-19978-0.004. */
12677 size_t maxlen = (end - p) - 1;
12678
12679 putchar ('"');
4082ef84
NC		 12680 if (maxlen > 0)
12681 {
12682 print_symbol ((int) maxlen, (const char *) p);
12683 p += strnlen ((char *) p, maxlen) + 1;
12684 }
12685 else
12686 {
12687 printf (_("<corrupt string tag>"));
12688 p = (unsigned char *) end;
12689 }
071436c6 12690 printf ("\"\n");
f6f0e17b
NC		 12691 }
12692 else
12693 {
12694 unsigned int len;
12695
12696 val = read_uleb128 (p, &len, end);
12697 p += len;
12698 printf ("%ld (0x%lx)\n", val, val);
12699 }
12700
4082ef84 12701 assert (p <= end);
f6f0e17b
NC		 12702 return p;
12703}
12704
11c1ff18
PB		 12705/* ARM EABI attributes section. */
12706typedef struct
12707{
70e99720 12708 unsigned int tag;
2cf0635d 12709 const char * name;
11c1ff18 12710 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12711 unsigned int type;
2cf0635d 12712 const char ** table;
11c1ff18
PB		 12713} arm_attr_public_tag;
12714
2cf0635d 12715static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12716 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12717 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12718static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12719static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12720 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12721static const char * arm_attr_tag_FP_arch[] =
bca38921 12722 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12723 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12724static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12725static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12726 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12727static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12728 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12729 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12730static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12731 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12732static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12733 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12734static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12735 {"Absolute", "PC-relative", "None"};
2cf0635d 12736static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12737 {"None", "direct", "GOT-indirect"};
2cf0635d 12738static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12739 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12740static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12741static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12742 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12743static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12744static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12745static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12746 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12747static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12748 {"Unused", "small", "int", "forced to int"};
2cf0635d 12749static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12750 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12751static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12752 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12753static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12754 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12755static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12756 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12757 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12758static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12759 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12760 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12761static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12762static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12763 {"Not Allowed", "Allowed"};
2cf0635d 12764static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12765 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12766static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12767 {"Not Allowed", "Allowed"};
12768static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12769 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12770 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12771static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12772static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12773 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12774 "TrustZone and Virtualization Extensions"};
dd24e3da 12775static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12776 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12777
12778#define LOOKUP(id, name) \
12779 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12780static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12781{
12782 {4, "CPU_raw_name", 1, NULL},
12783 {5, "CPU_name", 1, NULL},
12784 LOOKUP(6, CPU_arch),
12785 {7, "CPU_arch_profile", 0, NULL},
12786 LOOKUP(8, ARM_ISA_use),
12787 LOOKUP(9, THUMB_ISA_use),
75375b3e 12788 LOOKUP(10, FP_arch),
11c1ff18 12789 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12790 LOOKUP(12, Advanced_SIMD_arch),
12791 LOOKUP(13, PCS_config),
11c1ff18
PB		 12792 LOOKUP(14, ABI_PCS_R9_use),
12793 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12794 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12795 LOOKUP(17, ABI_PCS_GOT_use),
12796 LOOKUP(18, ABI_PCS_wchar_t),
12797 LOOKUP(19, ABI_FP_rounding),
12798 LOOKUP(20, ABI_FP_denormal),
12799 LOOKUP(21, ABI_FP_exceptions),
12800 LOOKUP(22, ABI_FP_user_exceptions),
12801 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12802 {24, "ABI_align_needed", 0, NULL},
12803 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12804 LOOKUP(26, ABI_enum_size),
12805 LOOKUP(27, ABI_HardFP_use),
12806 LOOKUP(28, ABI_VFP_args),
12807 LOOKUP(29, ABI_WMMX_args),
12808 LOOKUP(30, ABI_optimization_goals),
12809 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12810 {32, "compatibility", 0, NULL},
f5f53991 12811 LOOKUP(34, CPU_unaligned_access),
75375b3e 12812 LOOKUP(36, FP_HP_extension),
8e79c3df 12813 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12814 LOOKUP(42, MPextension_use),
12815 LOOKUP(44, DIV_use),
f5f53991
AS		 12816 {64, "nodefaults", 0, NULL},
12817 {65, "also_compatible_with", 0, NULL},
12818 LOOKUP(66, T2EE_use),
12819 {67, "conformance", 1, NULL},
12820 LOOKUP(68, Virtualization_use),
cd21e546 12821 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12822};
12823#undef LOOKUP
12824
11c1ff18 12825static unsigned char *
f6f0e17b
NC		 12826display_arm_attribute (unsigned char * p,
12827 const unsigned char * const end)
11c1ff18 12828{
70e99720 12829 unsigned int tag;
11c1ff18 12830 unsigned int len;
70e99720 12831 unsigned int val;
2cf0635d 12832 arm_attr_public_tag * attr;
11c1ff18 12833 unsigned i;
70e99720 12834 unsigned int type;
11c1ff18 12835
f6f0e17b 12836 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12837 p += len;
12838 attr = NULL;
2cf0635d 12839 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12840 {
12841 if (arm_attr_public_tags[i].tag == tag)
12842 {
12843 attr = &arm_attr_public_tags[i];
12844 break;
12845 }
12846 }
12847
12848 if (attr)
12849 {
12850 printf (" Tag_%s: ", attr->name);
12851 switch (attr->type)
12852 {
12853 case 0:
12854 switch (tag)
12855 {
12856 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12857 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12858 p += len;
12859 switch (val)
12860 {
2b692964
NC		 12861 case 0: printf (_("None\n")); break;
12862 case 'A': printf (_("Application\n")); break;
12863 case 'R': printf (_("Realtime\n")); break;
12864 case 'M': printf (_("Microcontroller\n")); break;
12865 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12866 default: printf ("??? (%d)\n", val); break;
12867 }
12868 break;
12869
75375b3e 12870 case 24: /* Tag_align_needed. */
f6f0e17b 12871 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12872 p += len;
12873 switch (val)
12874 {
2b692964
NC		 12875 case 0: printf (_("None\n")); break;
12876 case 1: printf (_("8-byte\n")); break;
12877 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12878 case 3: printf ("??? 3\n"); break;
12879 default:
12880 if (val <= 12)
dd24e3da 12881 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12882 1 << val);
12883 else
12884 printf ("??? (%d)\n", val);
12885 break;
12886 }
12887 break;
12888
12889 case 25: /* Tag_align_preserved. */
f6f0e17b 12890 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12891 p += len;
12892 switch (val)
12893 {
2b692964
NC		 12894 case 0: printf (_("None\n")); break;
12895 case 1: printf (_("8-byte, except leaf SP\n")); break;
12896 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12897 case 3: printf ("??? 3\n"); break;
12898 default:
12899 if (val <= 12)
dd24e3da 12900 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12901 1 << val);
12902 else
12903 printf ("??? (%d)\n", val);
12904 break;
12905 }
12906 break;
12907
11c1ff18 12908 case 32: /* Tag_compatibility. */
071436c6 12909 {
071436c6
NC		 12910 val = read_uleb128 (p, &len, end);
12911 p += len;
071436c6 12912 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12913 if (p < end - 1)
12914 {
12915 size_t maxlen = (end - p) - 1;
12916
12917 print_symbol ((int) maxlen, (const char *) p);
12918 p += strnlen ((char *) p, maxlen) + 1;
12919 }
12920 else
12921 {
12922 printf (_("<corrupt>"));
12923 p = (unsigned char *) end;
12924 }
071436c6 12925 putchar ('\n');
071436c6 12926 }
11c1ff18
PB		 12927 break;
12928
f5f53991 12929 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12930 /* PR 17531: file: 001-505008-0.01. */
12931 if (p < end)
12932 p++;
2b692964 12933 printf (_("True\n"));
f5f53991
AS		 12934 break;
12935
12936 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12937 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12938 p += len;
12939 if (val == 6 /* Tag_CPU_arch. */)
12940 {
f6f0e17b 12941 val = read_uleb128 (p, &len, end);
f5f53991 12942 p += len;
071436c6 12943 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12944 printf ("??? (%d)\n", val);
12945 else
12946 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12947 }
12948 else
12949 printf ("???\n");
071436c6
NC		 12950 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12951 ;
f5f53991
AS		 12952 break;
12953
11c1ff18 12954 default:
bee0ee85
NC		 12955 printf (_("<unknown: %d>\n"), tag);
12956 break;
11c1ff18
PB		 12957 }
12958 return p;
12959
12960 case 1:
f6f0e17b 12961 return display_tag_value (-1, p, end);
11c1ff18 12962 case 2:
f6f0e17b 12963 return display_tag_value (0, p, end);
11c1ff18
PB		 12964
12965 default:
12966 assert (attr->type & 0x80);
f6f0e17b 12967 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12968 p += len;
12969 type = attr->type & 0x7f;
12970 if (val >= type)
12971 printf ("??? (%d)\n", val);
12972 else
12973 printf ("%s\n", attr->table[val]);
12974 return p;
12975 }
12976 }
11c1ff18 12977
f6f0e17b 12978 return display_tag_value (tag, p, end);
11c1ff18
PB		 12979}
12980
104d59d1 12981static unsigned char *
60bca95a 12982display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12983 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12984 const unsigned char * const end)
104d59d1
JM		 12985{
12986 int tag;
12987 unsigned int len;
12988 int val;
104d59d1 12989
f6f0e17b 12990 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12991 p += len;
12992
12993 /* Tag_compatibility is the only generic GNU attribute defined at
12994 present. */
12995 if (tag == 32)
12996 {
f6f0e17b 12997 val = read_uleb128 (p, &len, end);
104d59d1 12998 p += len;
071436c6
NC		 12999
13000 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13001 if (p == end)
13002 {
071436c6 13003 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13004 warn (_("corrupt vendor attribute\n"));
13005 }
13006 else
13007 {
4082ef84
NC		 13008 if (p < end - 1)
13009 {
13010 size_t maxlen = (end - p) - 1;
071436c6 13011
4082ef84
NC		 13012 print_symbol ((int) maxlen, (const char *) p);
13013 p += strnlen ((char *) p, maxlen) + 1;
13014 }
13015 else
13016 {
13017 printf (_("<corrupt>"));
13018 p = (unsigned char *) end;
13019 }
071436c6 13020 putchar ('\n');
f6f0e17b 13021 }
104d59d1
JM		 13022 return p;
13023 }
13024
13025 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13026 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13027
f6f0e17b 13028 return display_tag_value (tag, p, end);
104d59d1
JM		 13029}
13030
34c8bcba 13031static unsigned char *
f6f0e17b
NC		 13032display_power_gnu_attribute (unsigned char * p,
13033 int tag,
13034 const unsigned char * const end)
34c8bcba 13035{
34c8bcba
JM		 13036 unsigned int len;
13037 int val;
13038
13039 if (tag == Tag_GNU_Power_ABI_FP)
13040 {
f6f0e17b 13041 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13042 p += len;
13043 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13044
34c8bcba
JM		 13045 switch (val)
13046 {
13047 case 0:
2b692964 13048 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13049 break;
13050 case 1:
2b692964 13051 printf (_("Hard float\n"));
34c8bcba
JM		 13052 break;
13053 case 2:
2b692964 13054 printf (_("Soft float\n"));
34c8bcba 13055 break;
3c7b9897 13056 case 3:
2b692964 13057 printf (_("Single-precision hard float\n"));
3c7b9897 13058 break;
34c8bcba
JM		 13059 default:
13060 printf ("??? (%d)\n", val);
13061 break;
13062 }
13063 return p;
13064 }
13065
c6e65352
DJ		 13066 if (tag == Tag_GNU_Power_ABI_Vector)
13067 {
f6f0e17b 13068 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13069 p += len;
13070 printf (" Tag_GNU_Power_ABI_Vector: ");
13071 switch (val)
13072 {
13073 case 0:
2b692964 13074 printf (_("Any\n"));
c6e65352
DJ		 13075 break;
13076 case 1:
2b692964 13077 printf (_("Generic\n"));
c6e65352
DJ		 13078 break;
13079 case 2:
13080 printf ("AltiVec\n");
13081 break;
13082 case 3:
13083 printf ("SPE\n");
13084 break;
13085 default:
13086 printf ("??? (%d)\n", val);
13087 break;
13088 }
13089 return p;
13090 }
13091
f82e0623
NF		 13092 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13093 {
f6f0e17b
NC		 13094 if (p == end)
13095 {
071436c6 13096 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13097 return p;
13098 }
0b4362b0 13099
f6f0e17b 13100 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13101 p += len;
13102 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13103 switch (val)
13104 {
13105 case 0:
2b692964 13106 printf (_("Any\n"));
f82e0623
NF		 13107 break;
13108 case 1:
13109 printf ("r3/r4\n");
13110 break;
13111 case 2:
2b692964 13112 printf (_("Memory\n"));
f82e0623
NF		 13113 break;
13114 default:
13115 printf ("??? (%d)\n", val);
13116 break;
13117 }
13118 return p;
13119 }
13120
f6f0e17b 13121 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13122}
13123
643f7afb
AK		 13124static unsigned char *
13125display_s390_gnu_attribute (unsigned char * p,
13126 int tag,
13127 const unsigned char * const end)
13128{
13129 unsigned int len;
13130 int val;
13131
13132 if (tag == Tag_GNU_S390_ABI_Vector)
13133 {
13134 val = read_uleb128 (p, &len, end);
13135 p += len;
13136 printf (" Tag_GNU_S390_ABI_Vector: ");
13137
13138 switch (val)
13139 {
13140 case 0:
13141 printf (_("any\n"));
13142 break;
13143 case 1:
13144 printf (_("software\n"));
13145 break;
13146 case 2:
13147 printf (_("hardware\n"));
13148 break;
13149 default:
13150 printf ("??? (%d)\n", val);
13151 break;
13152 }
13153 return p;
13154 }
13155
13156 return display_tag_value (tag & 1, p, end);
13157}
13158
9e8c70f9
DM		 13159static void
13160display_sparc_hwcaps (int mask)
13161{
13162 if (mask)
13163 {
13164 int first = 1;
071436c6 13165
9e8c70f9
DM		 13166 if (mask & ELF_SPARC_HWCAP_MUL32)
13167 fputs ("mul32", stdout), first = 0;
13168 if (mask & ELF_SPARC_HWCAP_DIV32)
13169 printf ("%sdiv32", first ? "" : "|"), first = 0;
13170 if (mask & ELF_SPARC_HWCAP_FSMULD)
13171 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13172 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13173 printf ("%sv8plus", first ? "" : "|"), first = 0;
13174 if (mask & ELF_SPARC_HWCAP_POPC)
13175 printf ("%spopc", first ? "" : "|"), first = 0;
13176 if (mask & ELF_SPARC_HWCAP_VIS)
13177 printf ("%svis", first ? "" : "|"), first = 0;
13178 if (mask & ELF_SPARC_HWCAP_VIS2)
13179 printf ("%svis2", first ? "" : "|"), first = 0;
13180 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13181 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13182 if (mask & ELF_SPARC_HWCAP_FMAF)
13183 printf ("%sfmaf", first ? "" : "|"), first = 0;
13184 if (mask & ELF_SPARC_HWCAP_VIS3)
13185 printf ("%svis3", first ? "" : "|"), first = 0;
13186 if (mask & ELF_SPARC_HWCAP_HPC)
13187 printf ("%shpc", first ? "" : "|"), first = 0;
13188 if (mask & ELF_SPARC_HWCAP_RANDOM)
13189 printf ("%srandom", first ? "" : "|"), first = 0;
13190 if (mask & ELF_SPARC_HWCAP_TRANS)
13191 printf ("%strans", first ? "" : "|"), first = 0;
13192 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13193 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13194 if (mask & ELF_SPARC_HWCAP_IMA)
13195 printf ("%sima", first ? "" : "|"), first = 0;
13196 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13197 printf ("%scspare", first ? "" : "|"), first = 0;
13198 }
13199 else
071436c6
NC		 13200 fputc ('0', stdout);
13201 fputc ('\n', stdout);
9e8c70f9
DM		 13202}
13203
3d68f91c
JM		 13204static void
13205display_sparc_hwcaps2 (int mask)
13206{
13207 if (mask)
13208 {
13209 int first = 1;
071436c6 13210
3d68f91c
JM		 13211 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13212 fputs ("fjathplus", stdout), first = 0;
13213 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13214 printf ("%svis3b", first ? "" : "|"), first = 0;
13215 if (mask & ELF_SPARC_HWCAP2_ADP)
13216 printf ("%sadp", first ? "" : "|"), first = 0;
13217 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13218 printf ("%ssparc5", first ? "" : "|"), first = 0;
13219 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13220 printf ("%smwait", first ? "" : "|"), first = 0;
13221 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13222 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13223 if (mask & ELF_SPARC_HWCAP2_XMONT)
13224 printf ("%sxmont2", first ? "" : "|"), first = 0;
13225 if (mask & ELF_SPARC_HWCAP2_NSEC)
13226 printf ("%snsec", first ? "" : "|"), first = 0;
13227 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13228 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13229 if (mask & ELF_SPARC_HWCAP2_FJDES)
13230 printf ("%sfjdes", first ? "" : "|"), first = 0;
13231 if (mask & ELF_SPARC_HWCAP2_FJAES)
13232 printf ("%sfjaes", first ? "" : "|"), first = 0;
13233 }
13234 else
071436c6
NC		 13235 fputc ('0', stdout);
13236 fputc ('\n', stdout);
3d68f91c
JM		 13237}
13238
9e8c70f9 13239static unsigned char *
f6f0e17b
NC		 13240display_sparc_gnu_attribute (unsigned char * p,
13241 int tag,
13242 const unsigned char * const end)
9e8c70f9 13243{
3d68f91c
JM		 13244 unsigned int len;
13245 int val;
13246
9e8c70f9
DM		 13247 if (tag == Tag_GNU_Sparc_HWCAPS)
13248 {
f6f0e17b 13249 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13250 p += len;
13251 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13252 display_sparc_hwcaps (val);
13253 return p;
3d68f91c
JM		 13254 }
13255 if (tag == Tag_GNU_Sparc_HWCAPS2)
13256 {
13257 val = read_uleb128 (p, &len, end);
13258 p += len;
13259 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13260 display_sparc_hwcaps2 (val);
13261 return p;
13262 }
9e8c70f9 13263
f6f0e17b 13264 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13265}
13266
351cdf24
MF		 13267static void
13268print_mips_fp_abi_value (int val)
13269{
13270 switch (val)
13271 {
13272 case Val_GNU_MIPS_ABI_FP_ANY:
13273 printf (_("Hard or soft float\n"));
13274 break;
13275 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13276 printf (_("Hard float (double precision)\n"));
13277 break;
13278 case Val_GNU_MIPS_ABI_FP_SINGLE:
13279 printf (_("Hard float (single precision)\n"));
13280 break;
13281 case Val_GNU_MIPS_ABI_FP_SOFT:
13282 printf (_("Soft float\n"));
13283 break;
13284 case Val_GNU_MIPS_ABI_FP_OLD_64:
13285 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13286 break;
13287 case Val_GNU_MIPS_ABI_FP_XX:
13288 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13289 break;
13290 case Val_GNU_MIPS_ABI_FP_64:
13291 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13292 break;
13293 case Val_GNU_MIPS_ABI_FP_64A:
13294 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13295 break;
3350cc01
CM		 13296 case Val_GNU_MIPS_ABI_FP_NAN2008:
13297 printf (_("NaN 2008 compatibility\n"));
13298 break;
351cdf24
MF		 13299 default:
13300 printf ("??? (%d)\n", val);
13301 break;
13302 }
13303}
13304
2cf19d5c 13305static unsigned char *
f6f0e17b
NC		 13306display_mips_gnu_attribute (unsigned char * p,
13307 int tag,
13308 const unsigned char * const end)
2cf19d5c 13309{
2cf19d5c
JM		 13310 if (tag == Tag_GNU_MIPS_ABI_FP)
13311 {
f6f0e17b
NC		 13312 unsigned int len;
13313 int val;
13314
13315 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13316 p += len;
13317 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13318
351cdf24
MF		 13319 print_mips_fp_abi_value (val);
13320
2cf19d5c
JM		 13321 return p;
13322 }
13323
a9f58168
CF		 13324 if (tag == Tag_GNU_MIPS_ABI_MSA)
13325 {
13326 unsigned int len;
13327 int val;
13328
13329 val = read_uleb128 (p, &len, end);
13330 p += len;
13331 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13332
13333 switch (val)
13334 {
13335 case Val_GNU_MIPS_ABI_MSA_ANY:
13336 printf (_("Any MSA or not\n"));
13337 break;
13338 case Val_GNU_MIPS_ABI_MSA_128:
13339 printf (_("128-bit MSA\n"));
13340 break;
13341 default:
13342 printf ("??? (%d)\n", val);
13343 break;
13344 }
13345 return p;
13346 }
13347
f6f0e17b 13348 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13349}
13350
59e6276b 13351static unsigned char *
f6f0e17b
NC		 13352display_tic6x_attribute (unsigned char * p,
13353 const unsigned char * const end)
59e6276b
JM		 13354{
13355 int tag;
13356 unsigned int len;
13357 int val;
13358
f6f0e17b 13359 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13360 p += len;
13361
13362 switch (tag)
13363 {
75fa6dc1 13364 case Tag_ISA:
f6f0e17b 13365 val = read_uleb128 (p, &len, end);
59e6276b 13366 p += len;
75fa6dc1 13367 printf (" Tag_ISA: ");
59e6276b
JM		 13368
13369 switch (val)
13370 {
75fa6dc1 13371 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13372 printf (_("None\n"));
13373 break;
75fa6dc1 13374 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13375 printf ("C62x\n");
13376 break;
75fa6dc1 13377 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13378 printf ("C67x\n");
13379 break;
75fa6dc1 13380 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13381 printf ("C67x+\n");
13382 break;
75fa6dc1 13383 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13384 printf ("C64x\n");
13385 break;
75fa6dc1 13386 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13387 printf ("C64x+\n");
13388 break;
75fa6dc1 13389 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13390 printf ("C674x\n");
13391 break;
13392 default:
13393 printf ("??? (%d)\n", val);
13394 break;
13395 }
13396 return p;
13397
87779176 13398 case Tag_ABI_wchar_t:
f6f0e17b 13399 val = read_uleb128 (p, &len, end);
87779176
JM		 13400 p += len;
13401 printf (" Tag_ABI_wchar_t: ");
13402 switch (val)
13403 {
13404 case 0:
13405 printf (_("Not used\n"));
13406 break;
13407 case 1:
13408 printf (_("2 bytes\n"));
13409 break;
13410 case 2:
13411 printf (_("4 bytes\n"));
13412 break;
13413 default:
13414 printf ("??? (%d)\n", val);
13415 break;
13416 }
13417 return p;
13418
13419 case Tag_ABI_stack_align_needed:
f6f0e17b 13420 val = read_uleb128 (p, &len, end);
87779176
JM		 13421 p += len;
13422 printf (" Tag_ABI_stack_align_needed: ");
13423 switch (val)
13424 {
13425 case 0:
13426 printf (_("8-byte\n"));
13427 break;
13428 case 1:
13429 printf (_("16-byte\n"));
13430 break;
13431 default:
13432 printf ("??? (%d)\n", val);
13433 break;
13434 }
13435 return p;
13436
13437 case Tag_ABI_stack_align_preserved:
f6f0e17b 13438 val = read_uleb128 (p, &len, end);
87779176
JM		 13439 p += len;
13440 printf (" Tag_ABI_stack_align_preserved: ");
13441 switch (val)
13442 {
13443 case 0:
13444 printf (_("8-byte\n"));
13445 break;
13446 case 1:
13447 printf (_("16-byte\n"));
13448 break;
13449 default:
13450 printf ("??? (%d)\n", val);
13451 break;
13452 }
13453 return p;
13454
b5593623 13455 case Tag_ABI_DSBT:
f6f0e17b 13456 val = read_uleb128 (p, &len, end);
b5593623
JM		 13457 p += len;
13458 printf (" Tag_ABI_DSBT: ");
13459 switch (val)
13460 {
13461 case 0:
13462 printf (_("DSBT addressing not used\n"));
13463 break;
13464 case 1:
13465 printf (_("DSBT addressing used\n"));
13466 break;
13467 default:
13468 printf ("??? (%d)\n", val);
13469 break;
13470 }
13471 return p;
13472
87779176 13473 case Tag_ABI_PID:
f6f0e17b 13474 val = read_uleb128 (p, &len, end);
87779176
JM		 13475 p += len;
13476 printf (" Tag_ABI_PID: ");
13477 switch (val)
13478 {
13479 case 0:
13480 printf (_("Data addressing position-dependent\n"));
13481 break;
13482 case 1:
13483 printf (_("Data addressing position-independent, GOT near DP\n"));
13484 break;
13485 case 2:
13486 printf (_("Data addressing position-independent, GOT far from DP\n"));
13487 break;
13488 default:
13489 printf ("??? (%d)\n", val);
13490 break;
13491 }
13492 return p;
13493
13494 case Tag_ABI_PIC:
f6f0e17b 13495 val = read_uleb128 (p, &len, end);
87779176
JM		 13496 p += len;
13497 printf (" Tag_ABI_PIC: ");
13498 switch (val)
13499 {
13500 case 0:
13501 printf (_("Code addressing position-dependent\n"));
13502 break;
13503 case 1:
13504 printf (_("Code addressing position-independent\n"));
13505 break;
13506 default:
13507 printf ("??? (%d)\n", val);
13508 break;
13509 }
13510 return p;
13511
13512 case Tag_ABI_array_object_alignment:
f6f0e17b 13513 val = read_uleb128 (p, &len, end);
87779176
JM		 13514 p += len;
13515 printf (" Tag_ABI_array_object_alignment: ");
13516 switch (val)
13517 {
13518 case 0:
13519 printf (_("8-byte\n"));
13520 break;
13521 case 1:
13522 printf (_("4-byte\n"));
13523 break;
13524 case 2:
13525 printf (_("16-byte\n"));
13526 break;
13527 default:
13528 printf ("??? (%d)\n", val);
13529 break;
13530 }
13531 return p;
13532
13533 case Tag_ABI_array_object_align_expected:
f6f0e17b 13534 val = read_uleb128 (p, &len, end);
87779176
JM		 13535 p += len;
13536 printf (" Tag_ABI_array_object_align_expected: ");
13537 switch (val)
13538 {
13539 case 0:
13540 printf (_("8-byte\n"));
13541 break;
13542 case 1:
13543 printf (_("4-byte\n"));
13544 break;
13545 case 2:
13546 printf (_("16-byte\n"));
13547 break;
13548 default:
13549 printf ("??? (%d)\n", val);
13550 break;
13551 }
13552 return p;
13553
3cbd1c06 13554 case Tag_ABI_compatibility:
071436c6 13555 {
071436c6
NC		 13556 val = read_uleb128 (p, &len, end);
13557 p += len;
13558 printf (" Tag_ABI_compatibility: ");
071436c6 13559 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13560 if (p < end - 1)
13561 {
13562 size_t maxlen = (end - p) - 1;
13563
13564 print_symbol ((int) maxlen, (const char *) p);
13565 p += strnlen ((char *) p, maxlen) + 1;
13566 }
13567 else
13568 {
13569 printf (_("<corrupt>"));
13570 p = (unsigned char *) end;
13571 }
071436c6 13572 putchar ('\n');
071436c6
NC		 13573 return p;
13574 }
87779176
JM		 13575
13576 case Tag_ABI_conformance:
071436c6 13577 {
4082ef84
NC		 13578 printf (" Tag_ABI_conformance: \"");
13579 if (p < end - 1)
13580 {
13581 size_t maxlen = (end - p) - 1;
071436c6 13582
4082ef84
NC		 13583 print_symbol ((int) maxlen, (const char *) p);
13584 p += strnlen ((char *) p, maxlen) + 1;
13585 }
13586 else
13587 {
13588 printf (_("<corrupt>"));
13589 p = (unsigned char *) end;
13590 }
071436c6 13591 printf ("\"\n");
071436c6
NC		 13592 return p;
13593 }
59e6276b
JM		 13594 }
13595
f6f0e17b
NC		 13596 return display_tag_value (tag, p, end);
13597}
59e6276b 13598
f6f0e17b
NC		 13599static void
13600display_raw_attribute (unsigned char * p, unsigned char * end)
13601{
13602 unsigned long addr = 0;
13603 size_t bytes = end - p;
13604
e0a31db1 13605 assert (end > p);
f6f0e17b 13606 while (bytes)
87779176 13607 {
f6f0e17b
NC		 13608 int j;
13609 int k;
13610 int lbytes = (bytes > 16 ? 16 : bytes);
13611
13612 printf (" 0x%8.8lx ", addr);
13613
13614 for (j = 0; j < 16; j++)
13615 {
13616 if (j < lbytes)
13617 printf ("%2.2x", p[j]);
13618 else
13619 printf (" ");
13620
13621 if ((j & 3) == 3)
13622 printf (" ");
13623 }
13624
13625 for (j = 0; j < lbytes; j++)
13626 {
13627 k = p[j];
13628 if (k >= ' ' && k < 0x7f)
13629 printf ("%c", k);
13630 else
13631 printf (".");
13632 }
13633
13634 putchar ('\n');
13635
13636 p += lbytes;
13637 bytes -= lbytes;
13638 addr += lbytes;
87779176 13639 }
59e6276b 13640
f6f0e17b 13641 putchar ('\n');
59e6276b
JM		 13642}
13643
13761a11
NC		 13644static unsigned char *
13645display_msp430x_attribute (unsigned char * p,
13646 const unsigned char * const end)
13647{
13648 unsigned int len;
13649 int val;
13650 int tag;
13651
13652 tag = read_uleb128 (p, & len, end);
13653 p += len;
0b4362b0 13654
13761a11
NC		 13655 switch (tag)
13656 {
13657 case OFBA_MSPABI_Tag_ISA:
13658 val = read_uleb128 (p, &len, end);
13659 p += len;
13660 printf (" Tag_ISA: ");
13661 switch (val)
13662 {
13663 case 0: printf (_("None\n")); break;
13664 case 1: printf (_("MSP430\n")); break;
13665 case 2: printf (_("MSP430X\n")); break;
13666 default: printf ("??? (%d)\n", val); break;
13667 }
13668 break;
13669
13670 case OFBA_MSPABI_Tag_Code_Model:
13671 val = read_uleb128 (p, &len, end);
13672 p += len;
13673 printf (" Tag_Code_Model: ");
13674 switch (val)
13675 {
13676 case 0: printf (_("None\n")); break;
13677 case 1: printf (_("Small\n")); break;
13678 case 2: printf (_("Large\n")); break;
13679 default: printf ("??? (%d)\n", val); break;
13680 }
13681 break;
13682
13683 case OFBA_MSPABI_Tag_Data_Model:
13684 val = read_uleb128 (p, &len, end);
13685 p += len;
13686 printf (" Tag_Data_Model: ");
13687 switch (val)
13688 {
13689 case 0: printf (_("None\n")); break;
13690 case 1: printf (_("Small\n")); break;
13691 case 2: printf (_("Large\n")); break;
13692 case 3: printf (_("Restricted Large\n")); break;
13693 default: printf ("??? (%d)\n", val); break;
13694 }
13695 break;
13696
13697 default:
13698 printf (_(" <unknown tag %d>: "), tag);
13699
13700 if (tag & 1)
13701 {
071436c6 13702 putchar ('"');
4082ef84
NC		 13703 if (p < end - 1)
13704 {
13705 size_t maxlen = (end - p) - 1;
13706
13707 print_symbol ((int) maxlen, (const char *) p);
13708 p += strnlen ((char *) p, maxlen) + 1;
13709 }
13710 else
13711 {
13712 printf (_("<corrupt>"));
13713 p = (unsigned char *) end;
13714 }
071436c6 13715 printf ("\"\n");
13761a11
NC		 13716 }
13717 else
13718 {
13719 val = read_uleb128 (p, &len, end);
13720 p += len;
13721 printf ("%d (0x%x)\n", val, val);
13722 }
13723 break;
13724 }
13725
4082ef84 13726 assert (p <= end);
13761a11
NC		 13727 return p;
13728}
13729
11c1ff18 13730static int
60bca95a
NC		 13731process_attributes (FILE * file,
13732 const char * public_name,
104d59d1 13733 unsigned int proc_type,
f6f0e17b
NC		 13734 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13735 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13736{
2cf0635d 13737 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13738 unsigned i;
13739
13740 /* Find the section header so that we get the size. */
13741 for (i = 0, sect = section_headers;
13742 i < elf_header.e_shnum;
13743 i++, sect++)
13744 {
071436c6
NC		 13745 unsigned char * contents;
13746 unsigned char * p;
13747
104d59d1 13748 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13749 continue;
13750
3f5e193b
NC		 13751 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13752 sect->sh_size, _("attributes"));
60bca95a 13753 if (contents == NULL)
11c1ff18 13754 continue;
60bca95a 13755
11c1ff18
PB		 13756 p = contents;
13757 if (*p == 'A')
13758 {
071436c6
NC		 13759 bfd_vma section_len;
13760
13761 section_len = sect->sh_size - 1;
11c1ff18 13762 p++;
60bca95a 13763
071436c6 13764 while (section_len > 0)
11c1ff18 13765 {
071436c6 13766 bfd_vma attr_len;
e9847026 13767 unsigned int namelen;
11c1ff18 13768 bfd_boolean public_section;
104d59d1 13769 bfd_boolean gnu_section;
11c1ff18 13770
071436c6 13771 if (section_len <= 4)
e0a31db1
NC		 13772 {
13773 error (_("Tag section ends prematurely\n"));
13774 break;
13775 }
071436c6 13776 attr_len = byte_get (p, 4);
11c1ff18 13777 p += 4;
60bca95a 13778
071436c6 13779 if (attr_len > section_len)
11c1ff18 13780 {
071436c6
NC		 13781 error (_("Bad attribute length (%u > %u)\n"),
13782 (unsigned) attr_len, (unsigned) section_len);
13783 attr_len = section_len;
11c1ff18 13784 }
74e1a04b 13785 /* PR 17531: file: 001-101425-0.004 */
071436c6 13786 else if (attr_len < 5)
74e1a04b 13787 {
071436c6 13788 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13789 break;
13790 }
e9847026 13791
071436c6
NC		 13792 section_len -= attr_len;
13793 attr_len -= 4;
13794
13795 namelen = strnlen ((char *) p, attr_len) + 1;
13796 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13797 {
13798 error (_("Corrupt attribute section name\n"));
13799 break;
13800 }
13801
071436c6
NC		 13802 printf (_("Attribute Section: "));
13803 print_symbol (INT_MAX, (const char *) p);
13804 putchar ('\n');
60bca95a
NC		 13805
13806 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13807 public_section = TRUE;
13808 else
13809 public_section = FALSE;
60bca95a
NC		 13810
13811 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13812 gnu_section = TRUE;
13813 else
13814 gnu_section = FALSE;
60bca95a 13815
11c1ff18 13816 p += namelen;
071436c6 13817 attr_len -= namelen;
e0a31db1 13818
071436c6 13819 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13820 {
e0a31db1 13821 int tag;
11c1ff18
PB		 13822 int val;
13823 bfd_vma size;
071436c6 13824 unsigned char * end;
60bca95a 13825
e0a31db1 13826 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13827 if (attr_len < 6)
e0a31db1
NC		 13828 {
13829 error (_("Unused bytes at end of section\n"));
13830 section_len = 0;
13831 break;
13832 }
13833
13834 tag = *(p++);
11c1ff18 13835 size = byte_get (p, 4);
071436c6 13836 if (size > attr_len)
11c1ff18 13837 {
e9847026 13838 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13839 (unsigned) size, (unsigned) attr_len);
13840 size = attr_len;
11c1ff18 13841 }
e0a31db1
NC		 13842 /* PR binutils/17531: Safe handling of corrupt files. */
13843 if (size < 6)
13844 {
13845 error (_("Bad subsection length (%u < 6)\n"),
13846 (unsigned) size);
13847 section_len = 0;
13848 break;
13849 }
60bca95a 13850
071436c6 13851 attr_len -= size;
11c1ff18 13852 end = p + size - 1;
071436c6 13853 assert (end <= contents + sect->sh_size);
11c1ff18 13854 p += 4;
60bca95a 13855
11c1ff18
PB		 13856 switch (tag)
13857 {
13858 case 1:
2b692964 13859 printf (_("File Attributes\n"));
11c1ff18
PB		 13860 break;
13861 case 2:
2b692964 13862 printf (_("Section Attributes:"));
11c1ff18
PB		 13863 goto do_numlist;
13864 case 3:
2b692964 13865 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13866 do_numlist:
13867 for (;;)
13868 {
91d6fa6a 13869 unsigned int j;
60bca95a 13870
f6f0e17b 13871 val = read_uleb128 (p, &j, end);
91d6fa6a 13872 p += j;
11c1ff18
PB		 13873 if (val == 0)
13874 break;
13875 printf (" %d", val);
13876 }
13877 printf ("\n");
13878 break;
13879 default:
2b692964 13880 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13881 public_section = FALSE;
13882 break;
13883 }
60bca95a 13884
071436c6 13885 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13886 {
13887 while (p < end)
f6f0e17b 13888 p = display_pub_attribute (p, end);
071436c6 13889 assert (p <= end);
104d59d1 13890 }
071436c6 13891 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13892 {
13893 while (p < end)
13894 p = display_gnu_attribute (p,
f6f0e17b
NC		 13895 display_proc_gnu_attribute,
13896 end);
071436c6 13897 assert (p <= end);
11c1ff18 13898 }
071436c6 13899 else if (p < end)
11c1ff18 13900 {
071436c6 13901 printf (_(" Unknown attribute:\n"));
f6f0e17b 13902 display_raw_attribute (p, end);
11c1ff18
PB		 13903 p = end;
13904 }
071436c6
NC		 13905 else
13906 attr_len = 0;
11c1ff18
PB		 13907 }
13908 }
13909 }
13910 else
e9847026 13911 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13912
60bca95a 13913 free (contents);
11c1ff18
PB		 13914 }
13915 return 1;
13916}
13917
104d59d1 13918static int
2cf0635d 13919process_arm_specific (FILE * file)
104d59d1
JM		 13920{
13921 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13922 display_arm_attribute, NULL);
13923}
13924
34c8bcba 13925static int
2cf0635d 13926process_power_specific (FILE * file)
34c8bcba
JM		 13927{
13928 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13929 display_power_gnu_attribute);
13930}
13931
643f7afb
AK		 13932static int
13933process_s390_specific (FILE * file)
13934{
13935 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13936 display_s390_gnu_attribute);
13937}
13938
9e8c70f9
DM		 13939static int
13940process_sparc_specific (FILE * file)
13941{
13942 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13943 display_sparc_gnu_attribute);
13944}
13945
59e6276b
JM		 13946static int
13947process_tic6x_specific (FILE * file)
13948{
13949 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13950 display_tic6x_attribute, NULL);
13951}
13952
13761a11
NC		 13953static int
13954process_msp430x_specific (FILE * file)
13955{
13956 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13957 display_msp430x_attribute, NULL);
13958}
13959
ccb4c951
RS		 13960/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13961 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13962 and return the VMA of the next entry, or -1 if there was a problem.
13963 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13964
13965static bfd_vma
82b1b41b
NC		 13966print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13967 unsigned char * data_end)
ccb4c951
RS		 13968{
13969 printf (" ");
13970 print_vma (addr, LONG_HEX);
13971 printf (" ");
13972 if (addr < pltgot + 0xfff0)
13973 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13974 else
13975 printf ("%10s", "");
13976 printf (" ");
13977 if (data == NULL)
2b692964 13978 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13979 else
13980 {
13981 bfd_vma entry;
82b1b41b 13982 unsigned char * from = data + addr - pltgot;
ccb4c951 13983
82b1b41b
NC		 13984 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13985 {
13986 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13987 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13988 return (bfd_vma) -1;
13989 }
13990 else
13991 {
13992 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13993 print_vma (entry, LONG_HEX);
13994 }
ccb4c951
RS		 13995 }
13996 return addr + (is_32bit_elf ? 4 : 8);
13997}
13998
861fb55a
DJ		 13999/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14000 PLTGOT. Print the Address and Initial fields of an entry at VMA
14001 ADDR and return the VMA of the next entry. */
14002
14003static bfd_vma
2cf0635d 14004print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14005{
14006 printf (" ");
14007 print_vma (addr, LONG_HEX);
14008 printf (" ");
14009 if (data == NULL)
2b692964 14010 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14011 else
14012 {
14013 bfd_vma entry;
14014
14015 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14016 print_vma (entry, LONG_HEX);
14017 }
14018 return addr + (is_32bit_elf ? 4 : 8);
14019}
14020
351cdf24
MF		 14021static void
14022print_mips_ases (unsigned int mask)
14023{
14024 if (mask & AFL_ASE_DSP)
14025 fputs ("\n\tDSP ASE", stdout);
14026 if (mask & AFL_ASE_DSPR2)
14027 fputs ("\n\tDSP R2 ASE", stdout);
14028 if (mask & AFL_ASE_EVA)
14029 fputs ("\n\tEnhanced VA Scheme", stdout);
14030 if (mask & AFL_ASE_MCU)
14031 fputs ("\n\tMCU (MicroController) ASE", stdout);
14032 if (mask & AFL_ASE_MDMX)
14033 fputs ("\n\tMDMX ASE", stdout);
14034 if (mask & AFL_ASE_MIPS3D)
14035 fputs ("\n\tMIPS-3D ASE", stdout);
14036 if (mask & AFL_ASE_MT)
14037 fputs ("\n\tMT ASE", stdout);
14038 if (mask & AFL_ASE_SMARTMIPS)
14039 fputs ("\n\tSmartMIPS ASE", stdout);
14040 if (mask & AFL_ASE_VIRT)
14041 fputs ("\n\tVZ ASE", stdout);
14042 if (mask & AFL_ASE_MSA)
14043 fputs ("\n\tMSA ASE", stdout);
14044 if (mask & AFL_ASE_MIPS16)
14045 fputs ("\n\tMIPS16 ASE", stdout);
14046 if (mask & AFL_ASE_MICROMIPS)
14047 fputs ("\n\tMICROMIPS ASE", stdout);
14048 if (mask & AFL_ASE_XPA)
14049 fputs ("\n\tXPA ASE", stdout);
14050 if (mask == 0)
14051 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14052 else if ((mask & ~AFL_ASE_MASK) != 0)
14053 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14054}
14055
14056static void
14057print_mips_isa_ext (unsigned int isa_ext)
14058{
14059 switch (isa_ext)
14060 {
14061 case 0:
14062 fputs (_("None"), stdout);
14063 break;
14064 case AFL_EXT_XLR:
14065 fputs ("RMI XLR", stdout);
14066 break;
2c629856
N		 14067 case AFL_EXT_OCTEON3:
14068 fputs ("Cavium Networks Octeon3", stdout);
14069 break;
351cdf24
MF		 14070 case AFL_EXT_OCTEON2:
14071 fputs ("Cavium Networks Octeon2", stdout);
14072 break;
14073 case AFL_EXT_OCTEONP:
14074 fputs ("Cavium Networks OcteonP", stdout);
14075 break;
14076 case AFL_EXT_LOONGSON_3A:
14077 fputs ("Loongson 3A", stdout);
14078 break;
14079 case AFL_EXT_OCTEON:
14080 fputs ("Cavium Networks Octeon", stdout);
14081 break;
14082 case AFL_EXT_5900:
14083 fputs ("Toshiba R5900", stdout);
14084 break;
14085 case AFL_EXT_4650:
14086 fputs ("MIPS R4650", stdout);
14087 break;
14088 case AFL_EXT_4010:
14089 fputs ("LSI R4010", stdout);
14090 break;
14091 case AFL_EXT_4100:
14092 fputs ("NEC VR4100", stdout);
14093 break;
14094 case AFL_EXT_3900:
14095 fputs ("Toshiba R3900", stdout);
14096 break;
14097 case AFL_EXT_10000:
14098 fputs ("MIPS R10000", stdout);
14099 break;
14100 case AFL_EXT_SB1:
14101 fputs ("Broadcom SB-1", stdout);
14102 break;
14103 case AFL_EXT_4111:
14104 fputs ("NEC VR4111/VR4181", stdout);
14105 break;
14106 case AFL_EXT_4120:
14107 fputs ("NEC VR4120", stdout);
14108 break;
14109 case AFL_EXT_5400:
14110 fputs ("NEC VR5400", stdout);
14111 break;
14112 case AFL_EXT_5500:
14113 fputs ("NEC VR5500", stdout);
14114 break;
14115 case AFL_EXT_LOONGSON_2E:
14116 fputs ("ST Microelectronics Loongson 2E", stdout);
14117 break;
14118 case AFL_EXT_LOONGSON_2F:
14119 fputs ("ST Microelectronics Loongson 2F", stdout);
14120 break;
14121 default:
00ac7aa0 14122 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14123 }
14124}
14125
14126static int
14127get_mips_reg_size (int reg_size)
14128{
14129 return (reg_size == AFL_REG_NONE) ? 0
14130 : (reg_size == AFL_REG_32) ? 32
14131 : (reg_size == AFL_REG_64) ? 64
14132 : (reg_size == AFL_REG_128) ? 128
14133 : -1;
14134}
14135
19e6b90e 14136static int
2cf0635d 14137process_mips_specific (FILE * file)
5b18a4bc 14138{
2cf0635d 14139 Elf_Internal_Dyn * entry;
351cdf24 14140 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14141 size_t liblist_offset = 0;
14142 size_t liblistno = 0;
14143 size_t conflictsno = 0;
14144 size_t options_offset = 0;
14145 size_t conflicts_offset = 0;
861fb55a
DJ		 14146 size_t pltrelsz = 0;
14147 size_t pltrel = 0;
ccb4c951 14148 bfd_vma pltgot = 0;
861fb55a
DJ		 14149 bfd_vma mips_pltgot = 0;
14150 bfd_vma jmprel = 0;
ccb4c951
RS		 14151 bfd_vma local_gotno = 0;
14152 bfd_vma gotsym = 0;
14153 bfd_vma symtabno = 0;
103f02d3 14154
2cf19d5c
JM		 14155 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14156 display_mips_gnu_attribute);
14157
351cdf24
MF		 14158 sect = find_section (".MIPS.abiflags");
14159
14160 if (sect != NULL)
14161 {
14162 Elf_External_ABIFlags_v0 *abiflags_ext;
14163 Elf_Internal_ABIFlags_v0 abiflags_in;
14164
14165 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14166 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14167 else
14168 {
14169 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14170 sect->sh_size, _("MIPS ABI Flags section"));
14171 if (abiflags_ext)
14172 {
14173 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14174 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14175 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14176 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14177 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14178 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14179 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14180 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14181 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14182 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14183 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14184
14185 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14186 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14187 if (abiflags_in.isa_rev > 1)
14188 printf ("r%d", abiflags_in.isa_rev);
14189 printf ("\nGPR size: %d",
14190 get_mips_reg_size (abiflags_in.gpr_size));
14191 printf ("\nCPR1 size: %d",
14192 get_mips_reg_size (abiflags_in.cpr1_size));
14193 printf ("\nCPR2 size: %d",
14194 get_mips_reg_size (abiflags_in.cpr2_size));
14195 fputs ("\nFP ABI: ", stdout);
14196 print_mips_fp_abi_value (abiflags_in.fp_abi);
14197 fputs ("ISA Extension: ", stdout);
14198 print_mips_isa_ext (abiflags_in.isa_ext);
14199 fputs ("\nASEs:", stdout);
14200 print_mips_ases (abiflags_in.ases);
14201 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14202 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14203 fputc ('\n', stdout);
14204 free (abiflags_ext);
14205 }
14206 }
14207 }
14208
19e6b90e
L		 14209 /* We have a lot of special sections. Thanks SGI! */
14210 if (dynamic_section == NULL)
14211 /* No information available. */
14212 return 0;
252b5132 14213
071436c6
NC		 14214 for (entry = dynamic_section;
14215 /* PR 17531 file: 012-50589-0.004. */
14216 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14217 ++entry)
252b5132
RH		 14218 switch (entry->d_tag)
14219 {
14220 case DT_MIPS_LIBLIST:
d93f0186
NC		 14221 liblist_offset
14222 = offset_from_vma (file, entry->d_un.d_val,
14223 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14224 break;
14225 case DT_MIPS_LIBLISTNO:
14226 liblistno = entry->d_un.d_val;
14227 break;
14228 case DT_MIPS_OPTIONS:
d93f0186 14229 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14230 break;
14231 case DT_MIPS_CONFLICT:
d93f0186
NC		 14232 conflicts_offset
14233 = offset_from_vma (file, entry->d_un.d_val,
14234 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14235 break;
14236 case DT_MIPS_CONFLICTNO:
14237 conflictsno = entry->d_un.d_val;
14238 break;
ccb4c951 14239 case DT_PLTGOT:
861fb55a
DJ		 14240 pltgot = entry->d_un.d_ptr;
14241 break;
ccb4c951
RS		 14242 case DT_MIPS_LOCAL_GOTNO:
14243 local_gotno = entry->d_un.d_val;
14244 break;
14245 case DT_MIPS_GOTSYM:
14246 gotsym = entry->d_un.d_val;
14247 break;
14248 case DT_MIPS_SYMTABNO:
14249 symtabno = entry->d_un.d_val;
14250 break;
861fb55a
DJ		 14251 case DT_MIPS_PLTGOT:
14252 mips_pltgot = entry->d_un.d_ptr;
14253 break;
14254 case DT_PLTREL:
14255 pltrel = entry->d_un.d_val;
14256 break;
14257 case DT_PLTRELSZ:
14258 pltrelsz = entry->d_un.d_val;
14259 break;
14260 case DT_JMPREL:
14261 jmprel = entry->d_un.d_ptr;
14262 break;
252b5132
RH		 14263 default:
14264 break;
14265 }
14266
14267 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14268 {
2cf0635d 14269 Elf32_External_Lib * elib;
252b5132
RH		 14270 size_t cnt;
14271
3f5e193b
NC		 14272 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14273 liblistno,
14274 sizeof (Elf32_External_Lib),
9cf03b7e 14275 _("liblist section data"));
a6e9f9df 14276 if (elib)
252b5132 14277 {
2b692964 14278 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14279 (unsigned long) liblistno);
2b692964 14280 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14281 stdout);
14282
14283 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14284 {
a6e9f9df 14285 Elf32_Lib liblist;
91d6fa6a 14286 time_t atime;
a6e9f9df 14287 char timebuf[20];
2cf0635d 14288 struct tm * tmp;
a6e9f9df
AM		 14289
14290 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14291 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14292 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14293 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14294 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14295
91d6fa6a 14296 tmp = gmtime (&atime);
e9e44622
JJ		 14297 snprintf (timebuf, sizeof (timebuf),
14298 "%04u-%02u-%02uT%02u:%02u:%02u",
14299 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14300 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14301
31104126 14302 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14303 if (VALID_DYNAMIC_NAME (liblist.l_name))
14304 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14305 else
2b692964 14306 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14307 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14308 liblist.l_version);
a6e9f9df
AM		 14309
14310 if (liblist.l_flags == 0)
2b692964 14311 puts (_(" NONE"));
a6e9f9df
AM		 14312 else
14313 {
14314 static const struct
252b5132 14315 {
2cf0635d 14316 const char * name;
a6e9f9df 14317 int bit;
252b5132 14318 }
a6e9f9df
AM		 14319 l_flags_vals[] =
14320 {
14321 { " EXACT_MATCH", LL_EXACT_MATCH },
14322 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14323 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14324 { " EXPORTS", LL_EXPORTS },
14325 { " DELAY_LOAD", LL_DELAY_LOAD },
14326 { " DELTA", LL_DELTA }
14327 };
14328 int flags = liblist.l_flags;
14329 size_t fcnt;
14330
60bca95a 14331 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14332 if ((flags & l_flags_vals[fcnt].bit) != 0)
14333 {
14334 fputs (l_flags_vals[fcnt].name, stdout);
14335 flags ^= l_flags_vals[fcnt].bit;
14336 }
14337 if (flags != 0)
14338 printf (" %#x", (unsigned int) flags);
252b5132 14339
a6e9f9df
AM		 14340 puts ("");
14341 }
252b5132 14342 }
252b5132 14343
a6e9f9df
AM		 14344 free (elib);
14345 }
252b5132
RH		 14346 }
14347
14348 if (options_offset != 0)
14349 {
2cf0635d 14350 Elf_External_Options * eopt;
2cf0635d
NC		 14351 Elf_Internal_Options * iopt;
14352 Elf_Internal_Options * option;
252b5132
RH		 14353 size_t offset;
14354 int cnt;
351cdf24 14355 sect = section_headers;
252b5132
RH		 14356
14357 /* Find the section header so that we get the size. */
071436c6 14358 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14359 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14360 if (sect == NULL)
14361 {
14362 error (_("No MIPS_OPTIONS header found\n"));
14363 return 0;
14364 }
252b5132 14365
3f5e193b
NC		 14366 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14367 sect->sh_size, _("options"));
a6e9f9df 14368 if (eopt)
252b5132 14369 {
3f5e193b
NC		 14370 iopt = (Elf_Internal_Options *)
14371 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14372 if (iopt == NULL)
14373 {
8b73c356 14374 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14375 return 0;
14376 }
76da6bbe 14377
a6e9f9df
AM		 14378 offset = cnt = 0;
14379 option = iopt;
252b5132 14380
82b1b41b 14381 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14382 {
2cf0635d 14383 Elf_External_Options * eoption;
252b5132 14384
a6e9f9df 14385 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14386
a6e9f9df
AM		 14387 option->kind = BYTE_GET (eoption->kind);
14388 option->size = BYTE_GET (eoption->size);
14389 option->section = BYTE_GET (eoption->section);
14390 option->info = BYTE_GET (eoption->info);
76da6bbe 14391
82b1b41b
NC		 14392 /* PR 17531: file: ffa0fa3b. */
14393 if (option->size < sizeof (* eopt)
14394 || offset + option->size > sect->sh_size)
14395 {
55325047
NC		 14396 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14397 return 0;
82b1b41b 14398 }
a6e9f9df 14399 offset += option->size;
14ae95f2 14400
a6e9f9df
AM		 14401 ++option;
14402 ++cnt;
14403 }
252b5132 14404
a6e9f9df 14405 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14406 printable_section_name (sect), cnt);
76da6bbe 14407
a6e9f9df 14408 option = iopt;
82b1b41b 14409 offset = 0;
252b5132 14410
a6e9f9df 14411 while (cnt-- > 0)
252b5132 14412 {
a6e9f9df
AM		 14413 size_t len;
14414
14415 switch (option->kind)
252b5132 14416 {
a6e9f9df
AM		 14417 case ODK_NULL:
14418 /* This shouldn't happen. */
14419 printf (" NULL %d %lx", option->section, option->info);
14420 break;
14421 case ODK_REGINFO:
14422 printf (" REGINFO ");
14423 if (elf_header.e_machine == EM_MIPS)
14424 {
14425 /* 32bit form. */
2cf0635d 14426 Elf32_External_RegInfo * ereg;
b34976b6 14427 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14428
14429 ereg = (Elf32_External_RegInfo *) (option + 1);
14430 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14431 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14432 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14433 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14434 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14435 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14436
14437 printf ("GPR %08lx GP 0x%lx\n",
14438 reginfo.ri_gprmask,
14439 (unsigned long) reginfo.ri_gp_value);
14440 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14441 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14442 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14443 }
14444 else
14445 {
14446 /* 64 bit form. */
2cf0635d 14447 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14448 Elf64_Internal_RegInfo reginfo;
14449
14450 ereg = (Elf64_External_RegInfo *) (option + 1);
14451 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14452 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14453 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14454 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14455 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14456 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14457
14458 printf ("GPR %08lx GP 0x",
14459 reginfo.ri_gprmask);
14460 printf_vma (reginfo.ri_gp_value);
14461 printf ("\n");
14462
14463 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14464 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14465 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14466 }
14467 ++option;
14468 continue;
14469 case ODK_EXCEPTIONS:
14470 fputs (" EXCEPTIONS fpe_min(", stdout);
14471 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14472 fputs (") fpe_max(", stdout);
14473 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14474 fputs (")", stdout);
14475
14476 if (option->info & OEX_PAGE0)
14477 fputs (" PAGE0", stdout);
14478 if (option->info & OEX_SMM)
14479 fputs (" SMM", stdout);
14480 if (option->info & OEX_FPDBUG)
14481 fputs (" FPDBUG", stdout);
14482 if (option->info & OEX_DISMISS)
14483 fputs (" DISMISS", stdout);
14484 break;
14485 case ODK_PAD:
14486 fputs (" PAD ", stdout);
14487 if (option->info & OPAD_PREFIX)
14488 fputs (" PREFIX", stdout);
14489 if (option->info & OPAD_POSTFIX)
14490 fputs (" POSTFIX", stdout);
14491 if (option->info & OPAD_SYMBOL)
14492 fputs (" SYMBOL", stdout);
14493 break;
14494 case ODK_HWPATCH:
14495 fputs (" HWPATCH ", stdout);
14496 if (option->info & OHW_R4KEOP)
14497 fputs (" R4KEOP", stdout);
14498 if (option->info & OHW_R8KPFETCH)
14499 fputs (" R8KPFETCH", stdout);
14500 if (option->info & OHW_R5KEOP)
14501 fputs (" R5KEOP", stdout);
14502 if (option->info & OHW_R5KCVTL)
14503 fputs (" R5KCVTL", stdout);
14504 break;
14505 case ODK_FILL:
14506 fputs (" FILL ", stdout);
14507 /* XXX Print content of info word? */
14508 break;
14509 case ODK_TAGS:
14510 fputs (" TAGS ", stdout);
14511 /* XXX Print content of info word? */
14512 break;
14513 case ODK_HWAND:
14514 fputs (" HWAND ", stdout);
14515 if (option->info & OHWA0_R4KEOP_CHECKED)
14516 fputs (" R4KEOP_CHECKED", stdout);
14517 if (option->info & OHWA0_R4KEOP_CLEAN)
14518 fputs (" R4KEOP_CLEAN", stdout);
14519 break;
14520 case ODK_HWOR:
14521 fputs (" HWOR ", stdout);
14522 if (option->info & OHWA0_R4KEOP_CHECKED)
14523 fputs (" R4KEOP_CHECKED", stdout);
14524 if (option->info & OHWA0_R4KEOP_CLEAN)
14525 fputs (" R4KEOP_CLEAN", stdout);
14526 break;
14527 case ODK_GP_GROUP:
14528 printf (" GP_GROUP %#06lx self-contained %#06lx",
14529 option->info & OGP_GROUP,
14530 (option->info & OGP_SELF) >> 16);
14531 break;
14532 case ODK_IDENT:
14533 printf (" IDENT %#06lx self-contained %#06lx",
14534 option->info & OGP_GROUP,
14535 (option->info & OGP_SELF) >> 16);
14536 break;
14537 default:
14538 /* This shouldn't happen. */
14539 printf (" %3d ??? %d %lx",
14540 option->kind, option->section, option->info);
14541 break;
252b5132 14542 }
a6e9f9df 14543
2cf0635d 14544 len = sizeof (* eopt);
a6e9f9df 14545 while (len < option->size)
82b1b41b 14546 {
7e27a9d5 14547 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14548
82b1b41b
NC		 14549 if (ISPRINT (datum))
14550 printf ("%c", datum);
14551 else
14552 printf ("\\%03o", datum);
14553 len ++;
14554 }
a6e9f9df 14555 fputs ("\n", stdout);
82b1b41b
NC		 14556
14557 offset += option->size;
252b5132 14558 ++option;
252b5132
RH		 14559 }
14560
a6e9f9df 14561 free (eopt);
252b5132 14562 }
252b5132
RH		 14563 }
14564
14565 if (conflicts_offset != 0 && conflictsno != 0)
14566 {
2cf0635d 14567 Elf32_Conflict * iconf;
252b5132
RH		 14568 size_t cnt;
14569
14570 if (dynamic_symbols == NULL)
14571 {
591a748a 14572 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14573 return 0;
14574 }
14575
3f5e193b 14576 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14577 if (iconf == NULL)
14578 {
8b73c356 14579 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14580 return 0;
14581 }
14582
9ea033b2 14583 if (is_32bit_elf)
252b5132 14584 {
2cf0635d 14585 Elf32_External_Conflict * econf32;
a6e9f9df 14586
3f5e193b
NC		 14587 econf32 = (Elf32_External_Conflict *)
14588 get_data (NULL, file, conflicts_offset, conflictsno,
14589 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14590 if (!econf32)
14591 return 0;
252b5132
RH		 14592
14593 for (cnt = 0; cnt < conflictsno; ++cnt)
14594 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14595
14596 free (econf32);
252b5132
RH		 14597 }
14598 else
14599 {
2cf0635d 14600 Elf64_External_Conflict * econf64;
a6e9f9df 14601
3f5e193b
NC		 14602 econf64 = (Elf64_External_Conflict *)
14603 get_data (NULL, file, conflicts_offset, conflictsno,
14604 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14605 if (!econf64)
14606 return 0;
252b5132
RH		 14607
14608 for (cnt = 0; cnt < conflictsno; ++cnt)
14609 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14610
14611 free (econf64);
252b5132
RH		 14612 }
14613
c7e7ca54
NC		 14614 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14615 (unsigned long) conflictsno);
252b5132
RH		 14616 puts (_(" Num: Index Value Name"));
14617
14618 for (cnt = 0; cnt < conflictsno; ++cnt)
14619 {
b34976b6 14620 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14621
14622 if (iconf[cnt] >= num_dynamic_syms)
14623 printf (_("<corrupt symbol index>"));
d79b3d50 14624 else
e0a31db1
NC		 14625 {
14626 Elf_Internal_Sym * psym;
14627
14628 psym = & dynamic_symbols[iconf[cnt]];
14629 print_vma (psym->st_value, FULL_HEX);
14630 putchar (' ');
14631 if (VALID_DYNAMIC_NAME (psym->st_name))
14632 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14633 else
14634 printf (_("<corrupt: %14ld>"), psym->st_name);
14635 }
31104126 14636 putchar ('\n');
252b5132
RH		 14637 }
14638
252b5132
RH		 14639 free (iconf);
14640 }
14641
ccb4c951
RS		 14642 if (pltgot != 0 && local_gotno != 0)
14643 {
91d6fa6a 14644 bfd_vma ent, local_end, global_end;
bbeee7ea 14645 size_t i, offset;
2cf0635d 14646 unsigned char * data;
82b1b41b 14647 unsigned char * data_end;
bbeee7ea 14648 int addr_size;
ccb4c951 14649
91d6fa6a 14650 ent = pltgot;
ccb4c951
RS		 14651 addr_size = (is_32bit_elf ? 4 : 8);
14652 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14653
74e1a04b
NC		 14654 /* PR binutils/17533 file: 012-111227-0.004 */
14655 if (symtabno < gotsym)
14656 {
14657 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14658 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14659 return 0;
14660 }
82b1b41b 14661
74e1a04b 14662 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14663 /* PR 17531: file: 54c91a34. */
14664 if (global_end < local_end)
14665 {
14666 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14667 return 0;
14668 }
948f632f 14669
ccb4c951 14670 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14671 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14672 global_end - pltgot, 1,
14673 _("Global Offset Table data"));
59245841
NC		 14674 if (data == NULL)
14675 return 0;
82b1b41b 14676 data_end = data + (global_end - pltgot);
59245841 14677
ccb4c951
RS		 14678 printf (_("\nPrimary GOT:\n"));
14679 printf (_(" Canonical gp value: "));
14680 print_vma (pltgot + 0x7ff0, LONG_HEX);
14681 printf ("\n\n");
14682
14683 printf (_(" Reserved entries:\n"));
14684 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14685 addr_size * 2, _("Address"), _("Access"),
14686 addr_size * 2, _("Initial"));
82b1b41b 14687 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14688 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14689 if (ent == (bfd_vma) -1)
14690 goto got_print_fail;
ccb4c951 14691 if (data
91d6fa6a 14692 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14693 >> (addr_size * 8 - 1)) != 0)
14694 {
82b1b41b 14695 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14696 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14697 if (ent == (bfd_vma) -1)
14698 goto got_print_fail;
ccb4c951
RS		 14699 }
14700 printf ("\n");
14701
91d6fa6a 14702 if (ent < local_end)
ccb4c951
RS		 14703 {
14704 printf (_(" Local entries:\n"));
cc5914eb 14705 printf (" %*s %10s %*s\n",
2b692964
NC		 14706 addr_size * 2, _("Address"), _("Access"),
14707 addr_size * 2, _("Initial"));
91d6fa6a 14708 while (ent < local_end)
ccb4c951 14709 {
82b1b41b 14710 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14711 printf ("\n");
82b1b41b
NC		 14712 if (ent == (bfd_vma) -1)
14713 goto got_print_fail;
ccb4c951
RS		 14714 }
14715 printf ("\n");
14716 }
14717
14718 if (gotsym < symtabno)
14719 {
14720 int sym_width;
14721
14722 printf (_(" Global entries:\n"));
cc5914eb 14723 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14724 addr_size * 2, _("Address"),
14725 _("Access"),
2b692964 14726 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14727 addr_size * 2, _("Sym.Val."),
14728 _("Type"),
14729 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14730 _("Ndx"), _("Name"));
0b4362b0 14731
ccb4c951 14732 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14733
ccb4c951
RS		 14734 for (i = gotsym; i < symtabno; i++)
14735 {
82b1b41b 14736 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14737 printf (" ");
e0a31db1
NC		 14738
14739 if (dynamic_symbols == NULL)
14740 printf (_("<no dynamic symbols>"));
14741 else if (i < num_dynamic_syms)
14742 {
14743 Elf_Internal_Sym * psym = dynamic_symbols + i;
14744
14745 print_vma (psym->st_value, LONG_HEX);
14746 printf (" %-7s %3s ",
14747 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14748 get_symbol_index_type (psym->st_shndx));
14749
14750 if (VALID_DYNAMIC_NAME (psym->st_name))
14751 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14752 else
14753 printf (_("<corrupt: %14ld>"), psym->st_name);
14754 }
ccb4c951 14755 else
7fc5ac57
JBG		 14756 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14757 (unsigned long) i);
e0a31db1 14758
ccb4c951 14759 printf ("\n");
82b1b41b
NC		 14760 if (ent == (bfd_vma) -1)
14761 break;
ccb4c951
RS		 14762 }
14763 printf ("\n");
14764 }
14765
82b1b41b 14766 got_print_fail:
ccb4c951
RS		 14767 if (data)
14768 free (data);
14769 }
14770
861fb55a
DJ		 14771 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14772 {
91d6fa6a 14773 bfd_vma ent, end;
861fb55a
DJ		 14774 size_t offset, rel_offset;
14775 unsigned long count, i;
2cf0635d 14776 unsigned char * data;
861fb55a 14777 int addr_size, sym_width;
2cf0635d 14778 Elf_Internal_Rela * rels;
861fb55a
DJ		 14779
14780 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14781 if (pltrel == DT_RELA)
14782 {
14783 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14784 return 0;
14785 }
14786 else
14787 {
14788 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14789 return 0;
14790 }
14791
91d6fa6a 14792 ent = mips_pltgot;
861fb55a
DJ		 14793 addr_size = (is_32bit_elf ? 4 : 8);
14794 end = mips_pltgot + (2 + count) * addr_size;
14795
14796 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14797 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14798 1, _("Procedure Linkage Table data"));
59245841
NC		 14799 if (data == NULL)
14800 return 0;
14801
9cf03b7e 14802 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14803 printf (_(" Reserved entries:\n"));
14804 printf (_(" %*s %*s Purpose\n"),
2b692964 14805 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14806 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14807 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14808 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14809 printf (_(" Module pointer\n"));
861fb55a
DJ		 14810 printf ("\n");
14811
14812 printf (_(" Entries:\n"));
cc5914eb 14813 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14814 addr_size * 2, _("Address"),
14815 addr_size * 2, _("Initial"),
14816 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14817 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14818 for (i = 0; i < count; i++)
14819 {
df97ab2a 14820 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14821
91d6fa6a 14822 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14823 printf (" ");
e0a31db1 14824
df97ab2a
MF		 14825 if (idx >= num_dynamic_syms)
14826 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14827 else
e0a31db1 14828 {
df97ab2a 14829 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14830
14831 print_vma (psym->st_value, LONG_HEX);
14832 printf (" %-7s %3s ",
14833 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14834 get_symbol_index_type (psym->st_shndx));
14835 if (VALID_DYNAMIC_NAME (psym->st_name))
14836 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14837 else
14838 printf (_("<corrupt: %14ld>"), psym->st_name);
14839 }
861fb55a
DJ		 14840 printf ("\n");
14841 }
14842 printf ("\n");
14843
14844 if (data)
14845 free (data);
14846 free (rels);
14847 }
14848
252b5132
RH		 14849 return 1;
14850}
14851
35c08157
KLC		 14852static int
14853process_nds32_specific (FILE * file)
14854{
14855 Elf_Internal_Shdr *sect = NULL;
14856
14857 sect = find_section (".nds32_e_flags");
14858 if (sect != NULL)
14859 {
14860 unsigned int *flag;
14861
14862 printf ("\nNDS32 elf flags section:\n");
14863 flag = get_data (NULL, file, sect->sh_offset, 1,
14864 sect->sh_size, _("NDS32 elf flags section"));
14865
14866 switch ((*flag) & 0x3)
14867 {
14868 case 0:
14869 printf ("(VEC_SIZE):\tNo entry.\n");
14870 break;
14871 case 1:
14872 printf ("(VEC_SIZE):\t4 bytes\n");
14873 break;
14874 case 2:
14875 printf ("(VEC_SIZE):\t16 bytes\n");
14876 break;
14877 case 3:
14878 printf ("(VEC_SIZE):\treserved\n");
14879 break;
14880 }
14881 }
14882
14883 return TRUE;
14884}
14885
047b2264 14886static int
2cf0635d 14887process_gnu_liblist (FILE * file)
047b2264 14888{
2cf0635d
NC		 14889 Elf_Internal_Shdr * section;
14890 Elf_Internal_Shdr * string_sec;
14891 Elf32_External_Lib * elib;
14892 char * strtab;
c256ffe7 14893 size_t strtab_size;
047b2264
JJ		 14894 size_t cnt;
14895 unsigned i;
14896
14897 if (! do_arch)
14898 return 0;
14899
14900 for (i = 0, section = section_headers;
14901 i < elf_header.e_shnum;
b34976b6 14902 i++, section++)
047b2264
JJ		 14903 {
14904 switch (section->sh_type)
14905 {
14906 case SHT_GNU_LIBLIST:
4fbb74a6 14907 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14908 break;
14909
3f5e193b
NC		 14910 elib = (Elf32_External_Lib *)
14911 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14912 _("liblist section data"));
047b2264
JJ		 14913
14914 if (elib == NULL)
14915 break;
4fbb74a6 14916 string_sec = section_headers + section->sh_link;
047b2264 14917
3f5e193b
NC		 14918 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14919 string_sec->sh_size,
14920 _("liblist string table"));
047b2264
JJ		 14921 if (strtab == NULL
14922 || section->sh_entsize != sizeof (Elf32_External_Lib))
14923 {
14924 free (elib);
2842702f 14925 free (strtab);
047b2264
JJ		 14926 break;
14927 }
59245841 14928 strtab_size = string_sec->sh_size;
047b2264
JJ		 14929
14930 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14931 printable_section_name (section),
0af1713e 14932 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14933
2b692964 14934 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14935
14936 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14937 ++cnt)
14938 {
14939 Elf32_Lib liblist;
91d6fa6a 14940 time_t atime;
047b2264 14941 char timebuf[20];
2cf0635d 14942 struct tm * tmp;
047b2264
JJ		 14943
14944 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14945 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14946 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14947 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14948 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14949
91d6fa6a 14950 tmp = gmtime (&atime);
e9e44622
JJ		 14951 snprintf (timebuf, sizeof (timebuf),
14952 "%04u-%02u-%02uT%02u:%02u:%02u",
14953 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14954 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14955
14956 printf ("%3lu: ", (unsigned long) cnt);
14957 if (do_wide)
c256ffe7 14958 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14959 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14960 else
c256ffe7 14961 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14962 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14963 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14964 liblist.l_version, liblist.l_flags);
14965 }
14966
14967 free (elib);
2842702f 14968 free (strtab);
047b2264
JJ		 14969 }
14970 }
14971
14972 return 1;
14973}
14974
9437c45b 14975static const char *
d3ba0551 14976get_note_type (unsigned e_type)
779fe533
NC		 14977{
14978 static char buff[64];
103f02d3 14979
1ec5cd37
NC		 14980 if (elf_header.e_type == ET_CORE)
14981 switch (e_type)
14982 {
57346661 14983 case NT_AUXV:
1ec5cd37 14984 return _("NT_AUXV (auxiliary vector)");
57346661 14985 case NT_PRSTATUS:
1ec5cd37 14986 return _("NT_PRSTATUS (prstatus structure)");
57346661 14987 case NT_FPREGSET:
1ec5cd37 14988 return _("NT_FPREGSET (floating point registers)");
57346661 14989 case NT_PRPSINFO:
1ec5cd37 14990 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14991 case NT_TASKSTRUCT:
1ec5cd37 14992 return _("NT_TASKSTRUCT (task structure)");
57346661 14993 case NT_PRXFPREG:
1ec5cd37 14994 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14995 case NT_PPC_VMX:
14996 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14997 case NT_PPC_VSX:
14998 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 14999 case NT_386_TLS:
15000 return _("NT_386_TLS (x86 TLS information)");
15001 case NT_386_IOPERM:
15002 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15003 case NT_X86_XSTATE:
15004 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15005 case NT_S390_HIGH_GPRS:
15006 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15007 case NT_S390_TIMER:
15008 return _("NT_S390_TIMER (s390 timer register)");
15009 case NT_S390_TODCMP:
15010 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15011 case NT_S390_TODPREG:
15012 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15013 case NT_S390_CTRS:
15014 return _("NT_S390_CTRS (s390 control registers)");
15015 case NT_S390_PREFIX:
15016 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15017 case NT_S390_LAST_BREAK:
15018 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15019 case NT_S390_SYSTEM_CALL:
15020 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15021 case NT_S390_TDB:
15022 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15023 case NT_S390_VXRS_LOW:
15024 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15025 case NT_S390_VXRS_HIGH:
15026 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15027 case NT_ARM_VFP:
15028 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15029 case NT_ARM_TLS:
15030 return _("NT_ARM_TLS (AArch TLS registers)");
15031 case NT_ARM_HW_BREAK:
15032 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15033 case NT_ARM_HW_WATCH:
15034 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15035 case NT_PSTATUS:
1ec5cd37 15036 return _("NT_PSTATUS (pstatus structure)");
57346661 15037 case NT_FPREGS:
1ec5cd37 15038 return _("NT_FPREGS (floating point registers)");
57346661 15039 case NT_PSINFO:
1ec5cd37 15040 return _("NT_PSINFO (psinfo structure)");
57346661 15041 case NT_LWPSTATUS:
1ec5cd37 15042 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15043 case NT_LWPSINFO:
1ec5cd37 15044 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15045 case NT_WIN32PSTATUS:
1ec5cd37 15046 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15047 case NT_SIGINFO:
15048 return _("NT_SIGINFO (siginfo_t data)");
15049 case NT_FILE:
15050 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15051 default:
15052 break;
15053 }
15054 else
15055 switch (e_type)
15056 {
15057 case NT_VERSION:
15058 return _("NT_VERSION (version)");
15059 case NT_ARCH:
15060 return _("NT_ARCH (architecture)");
15061 default:
15062 break;
15063 }
15064
e9e44622 15065 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15066 return buff;
779fe533
NC		 15067}
15068
9ece1fa9
TT		 15069static int
15070print_core_note (Elf_Internal_Note *pnote)
15071{
15072 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15073 bfd_vma count, page_size;
15074 unsigned char *descdata, *filenames, *descend;
15075
15076 if (pnote->type != NT_FILE)
15077 return 1;
15078
15079#ifndef BFD64
15080 if (!is_32bit_elf)
15081 {
15082 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15083 /* Still "successful". */
15084 return 1;
15085 }
15086#endif
15087
15088 if (pnote->descsz < 2 * addr_size)
15089 {
15090 printf (_(" Malformed note - too short for header\n"));
15091 return 0;
15092 }
15093
15094 descdata = (unsigned char *) pnote->descdata;
15095 descend = descdata + pnote->descsz;
15096
15097 if (descdata[pnote->descsz - 1] != '\0')
15098 {
15099 printf (_(" Malformed note - does not end with \\0\n"));
15100 return 0;
15101 }
15102
15103 count = byte_get (descdata, addr_size);
15104 descdata += addr_size;
15105
15106 page_size = byte_get (descdata, addr_size);
15107 descdata += addr_size;
15108
15109 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15110 {
15111 printf (_(" Malformed note - too short for supplied file count\n"));
15112 return 0;
15113 }
15114
15115 printf (_(" Page size: "));
15116 print_vma (page_size, DEC);
15117 printf ("\n");
15118
15119 printf (_(" %*s%*s%*s\n"),
15120 (int) (2 + 2 * addr_size), _("Start"),
15121 (int) (4 + 2 * addr_size), _("End"),
15122 (int) (4 + 2 * addr_size), _("Page Offset"));
15123 filenames = descdata + count * 3 * addr_size;
595712bb 15124 while (count-- > 0)
9ece1fa9
TT		 15125 {
15126 bfd_vma start, end, file_ofs;
15127
15128 if (filenames == descend)
15129 {
15130 printf (_(" Malformed note - filenames end too early\n"));
15131 return 0;
15132 }
15133
15134 start = byte_get (descdata, addr_size);
15135 descdata += addr_size;
15136 end = byte_get (descdata, addr_size);
15137 descdata += addr_size;
15138 file_ofs = byte_get (descdata, addr_size);
15139 descdata += addr_size;
15140
15141 printf (" ");
15142 print_vma (start, FULL_HEX);
15143 printf (" ");
15144 print_vma (end, FULL_HEX);
15145 printf (" ");
15146 print_vma (file_ofs, FULL_HEX);
15147 printf ("\n %s\n", filenames);
15148
15149 filenames += 1 + strlen ((char *) filenames);
15150 }
15151
15152 return 1;
15153}
15154
1118d252
RM		 15155static const char *
15156get_gnu_elf_note_type (unsigned e_type)
15157{
15158 static char buff[64];
15159
15160 switch (e_type)
15161 {
15162 case NT_GNU_ABI_TAG:
15163 return _("NT_GNU_ABI_TAG (ABI version tag)");
15164 case NT_GNU_HWCAP:
15165 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15166 case NT_GNU_BUILD_ID:
15167 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15168 case NT_GNU_GOLD_VERSION:
15169 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15170 default:
15171 break;
15172 }
15173
15174 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15175 return buff;
15176}
15177
664f90a3
TT		 15178static int
15179print_gnu_note (Elf_Internal_Note *pnote)
15180{
15181 switch (pnote->type)
15182 {
15183 case NT_GNU_BUILD_ID:
15184 {
15185 unsigned long i;
15186
15187 printf (_(" Build ID: "));
15188 for (i = 0; i < pnote->descsz; ++i)
15189 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15190 printf ("\n");
664f90a3
TT		 15191 }
15192 break;
15193
15194 case NT_GNU_ABI_TAG:
15195 {
15196 unsigned long os, major, minor, subminor;
15197 const char *osname;
15198
3102e897
NC		 15199 /* PR 17531: file: 030-599401-0.004. */
15200 if (pnote->descsz < 16)
15201 {
15202 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15203 break;
15204 }
15205
664f90a3
TT		 15206 os = byte_get ((unsigned char *) pnote->descdata, 4);
15207 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15208 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15209 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15210
15211 switch (os)
15212 {
15213 case GNU_ABI_TAG_LINUX:
15214 osname = "Linux";
15215 break;
15216 case GNU_ABI_TAG_HURD:
15217 osname = "Hurd";
15218 break;
15219 case GNU_ABI_TAG_SOLARIS:
15220 osname = "Solaris";
15221 break;
15222 case GNU_ABI_TAG_FREEBSD:
15223 osname = "FreeBSD";
15224 break;
15225 case GNU_ABI_TAG_NETBSD:
15226 osname = "NetBSD";
15227 break;
14ae95f2
RM		 15228 case GNU_ABI_TAG_SYLLABLE:
15229 osname = "Syllable";
15230 break;
15231 case GNU_ABI_TAG_NACL:
15232 osname = "NaCl";
15233 break;
664f90a3
TT		 15234 default:
15235 osname = "Unknown";
15236 break;
15237 }
15238
15239 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15240 major, minor, subminor);
15241 }
15242 break;
926c5385
CC		 15243
15244 case NT_GNU_GOLD_VERSION:
15245 {
15246 unsigned long i;
15247
15248 printf (_(" Version: "));
15249 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15250 printf ("%c", pnote->descdata[i]);
15251 printf ("\n");
15252 }
15253 break;
664f90a3
TT		 15254 }
15255
15256 return 1;
15257}
15258
685080f2
NC		 15259static const char *
15260get_v850_elf_note_type (enum v850_notes n_type)
15261{
15262 static char buff[64];
15263
15264 switch (n_type)
15265 {
15266 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15267 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15268 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15269 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15270 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15271 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15272 default:
15273 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15274 return buff;
15275 }
15276}
15277
15278static int
15279print_v850_note (Elf_Internal_Note * pnote)
15280{
15281 unsigned int val;
15282
15283 if (pnote->descsz != 4)
15284 return 0;
15285 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15286
15287 if (val == 0)
15288 {
15289 printf (_("not set\n"));
15290 return 1;
15291 }
15292
15293 switch (pnote->type)
15294 {
15295 case V850_NOTE_ALIGNMENT:
15296 switch (val)
15297 {
15298 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15299 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15300 }
15301 break;
14ae95f2 15302
685080f2
NC		 15303 case V850_NOTE_DATA_SIZE:
15304 switch (val)
15305 {
15306 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15307 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15308 }
15309 break;
14ae95f2 15310
685080f2
NC		 15311 case V850_NOTE_FPU_INFO:
15312 switch (val)
15313 {
15314 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15315 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15316 }
15317 break;
14ae95f2 15318
685080f2
NC		 15319 case V850_NOTE_MMU_INFO:
15320 case V850_NOTE_CACHE_INFO:
15321 case V850_NOTE_SIMD_INFO:
15322 if (val == EF_RH850_SIMD)
15323 {
15324 printf (_("yes\n"));
15325 return 1;
15326 }
15327 break;
15328
15329 default:
15330 /* An 'unknown note type' message will already have been displayed. */
15331 break;
15332 }
15333
15334 printf (_("unknown value: %x\n"), val);
15335 return 0;
15336}
15337
c6056a74
SF		 15338static int
15339process_netbsd_elf_note (Elf_Internal_Note * pnote)
15340{
15341 unsigned int version;
15342
15343 switch (pnote->type)
15344 {
15345 case NT_NETBSD_IDENT:
15346 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15347 if ((version / 10000) % 100)
15348 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15349 version, version / 100000000, (version / 1000000) % 100,
15350 (version / 10000) % 100 > 26 ? "Z" : "",
15351 'A' + (version / 10000) % 26);
15352 else
15353 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15354 version, version / 100000000, (version / 1000000) % 100,
15355 (version / 100) % 100);
15356 return 1;
15357
15358 case NT_NETBSD_MARCH:
15359 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15360 pnote->descdata);
15361 return 1;
15362
15363 default:
15364 break;
15365 }
15366
15367 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15368 pnote->type);
15369 return 1;
15370}
15371
9437c45b 15372static const char *
d3ba0551 15373get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15374{
15375 static char buff[64];
15376
b4db1224 15377 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15378 {
15379 /* NetBSD core "procinfo" structure. */
15380 return _("NetBSD procinfo structure");
15381 }
15382
15383 /* As of Jan 2002 there are no other machine-independent notes
15384 defined for NetBSD core files. If the note type is less
15385 than the start of the machine-dependent note types, we don't
15386 understand it. */
15387
b4db1224 15388 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15389 {
e9e44622 15390 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15391 return buff;
15392 }
15393
15394 switch (elf_header.e_machine)
15395 {
15396 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15397 and PT_GETFPREGS == mach+2. */
15398
15399 case EM_OLD_ALPHA:
15400 case EM_ALPHA:
15401 case EM_SPARC:
15402 case EM_SPARC32PLUS:
15403 case EM_SPARCV9:
15404 switch (e_type)
15405 {
2b692964 15406 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15407 return _("PT_GETREGS (reg structure)");
2b692964 15408 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15409 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15410 default:
15411 break;
15412 }
15413 break;
15414
15415 /* On all other arch's, PT_GETREGS == mach+1 and
15416 PT_GETFPREGS == mach+3. */
15417 default:
15418 switch (e_type)
15419 {
2b692964 15420 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15421 return _("PT_GETREGS (reg structure)");
2b692964 15422 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15423 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15424 default:
15425 break;
15426 }
15427 }
15428
9cf03b7e 15429 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15430 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15431 return buff;
15432}
15433
70616151
TT		 15434static const char *
15435get_stapsdt_note_type (unsigned e_type)
15436{
15437 static char buff[64];
15438
15439 switch (e_type)
15440 {
15441 case NT_STAPSDT:
15442 return _("NT_STAPSDT (SystemTap probe descriptors)");
15443
15444 default:
15445 break;
15446 }
15447
15448 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15449 return buff;
15450}
15451
c6a9fc58
TT		 15452static int
15453print_stapsdt_note (Elf_Internal_Note *pnote)
15454{
15455 int addr_size = is_32bit_elf ? 4 : 8;
15456 char *data = pnote->descdata;
15457 char *data_end = pnote->descdata + pnote->descsz;
15458 bfd_vma pc, base_addr, semaphore;
15459 char *provider, *probe, *arg_fmt;
15460
15461 pc = byte_get ((unsigned char *) data, addr_size);
15462 data += addr_size;
15463 base_addr = byte_get ((unsigned char *) data, addr_size);
15464 data += addr_size;
15465 semaphore = byte_get ((unsigned char *) data, addr_size);
15466 data += addr_size;
15467
15468 provider = data;
15469 data += strlen (data) + 1;
15470 probe = data;
15471 data += strlen (data) + 1;
15472 arg_fmt = data;
15473 data += strlen (data) + 1;
15474
15475 printf (_(" Provider: %s\n"), provider);
15476 printf (_(" Name: %s\n"), probe);
15477 printf (_(" Location: "));
15478 print_vma (pc, FULL_HEX);
15479 printf (_(", Base: "));
15480 print_vma (base_addr, FULL_HEX);
15481 printf (_(", Semaphore: "));
15482 print_vma (semaphore, FULL_HEX);
9cf03b7e 15483 printf ("\n");
c6a9fc58
TT		 15484 printf (_(" Arguments: %s\n"), arg_fmt);
15485
15486 return data == data_end;
15487}
15488
00e98fc7
TG		 15489static const char *
15490get_ia64_vms_note_type (unsigned e_type)
15491{
15492 static char buff[64];
15493
15494 switch (e_type)
15495 {
15496 case NT_VMS_MHD:
15497 return _("NT_VMS_MHD (module header)");
15498 case NT_VMS_LNM:
15499 return _("NT_VMS_LNM (language name)");
15500 case NT_VMS_SRC:
15501 return _("NT_VMS_SRC (source files)");
15502 case NT_VMS_TITLE:
9cf03b7e 15503 return "NT_VMS_TITLE";
00e98fc7
TG		 15504 case NT_VMS_EIDC:
15505 return _("NT_VMS_EIDC (consistency check)");
15506 case NT_VMS_FPMODE:
15507 return _("NT_VMS_FPMODE (FP mode)");
15508 case NT_VMS_LINKTIME:
9cf03b7e 15509 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15510 case NT_VMS_IMGNAM:
15511 return _("NT_VMS_IMGNAM (image name)");
15512 case NT_VMS_IMGID:
15513 return _("NT_VMS_IMGID (image id)");
15514 case NT_VMS_LINKID:
15515 return _("NT_VMS_LINKID (link id)");
15516 case NT_VMS_IMGBID:
15517 return _("NT_VMS_IMGBID (build id)");
15518 case NT_VMS_GSTNAM:
15519 return _("NT_VMS_GSTNAM (sym table name)");
15520 case NT_VMS_ORIG_DYN:
9cf03b7e 15521 return "NT_VMS_ORIG_DYN";
00e98fc7 15522 case NT_VMS_PATCHTIME:
9cf03b7e 15523 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15524 default:
15525 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15526 return buff;
15527 }
15528}
15529
15530static int
15531print_ia64_vms_note (Elf_Internal_Note * pnote)
15532{
15533 switch (pnote->type)
15534 {
15535 case NT_VMS_MHD:
15536 if (pnote->descsz > 36)
15537 {
15538 size_t l = strlen (pnote->descdata + 34);
15539 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15540 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15541 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15542 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15543 }
15544 else
15545 printf (_(" Invalid size\n"));
15546 break;
15547 case NT_VMS_LNM:
15548 printf (_(" Language: %s\n"), pnote->descdata);
15549 break;
15550#ifdef BFD64
15551 case NT_VMS_FPMODE:
9cf03b7e 15552 printf (_(" Floating Point mode: "));
4a5cb34f 15553 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15554 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15555 break;
15556 case NT_VMS_LINKTIME:
15557 printf (_(" Link time: "));
15558 print_vms_time
15559 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15560 printf ("\n");
15561 break;
15562 case NT_VMS_PATCHTIME:
15563 printf (_(" Patch time: "));
15564 print_vms_time
15565 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15566 printf ("\n");
15567 break;
15568 case NT_VMS_ORIG_DYN:
15569 printf (_(" Major id: %u, minor id: %u\n"),
15570 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15571 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15572 printf (_(" Last modified : "));
00e98fc7
TG		 15573 print_vms_time
15574 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15575 printf (_("\n Link flags : "));
4a5cb34f 15576 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15577 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15578 printf (_(" Header flags: 0x%08x\n"),
948f632f 15579 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15580 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15581 break;
15582#endif
15583 case NT_VMS_IMGNAM:
15584 printf (_(" Image name: %s\n"), pnote->descdata);
15585 break;
15586 case NT_VMS_GSTNAM:
15587 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15588 break;
15589 case NT_VMS_IMGID:
15590 printf (_(" Image id: %s\n"), pnote->descdata);
15591 break;
15592 case NT_VMS_LINKID:
15593 printf (_(" Linker id: %s\n"), pnote->descdata);
15594 break;
15595 default:
15596 break;
15597 }
15598 return 1;
15599}
15600
6d118b09
NC		 15601/* Note that by the ELF standard, the name field is already null byte
15602 terminated, and namesz includes the terminating null byte.
15603 I.E. the value of namesz for the name "FSF" is 4.
15604
e3c8793a 15605 If the value of namesz is zero, there is no name present. */
779fe533 15606static int
2cf0635d 15607process_note (Elf_Internal_Note * pnote)
779fe533 15608{
2cf0635d
NC		 15609 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15610 const char * nt;
9437c45b
JT		 15611
15612 if (pnote->namesz == 0)
1ec5cd37
NC		 15613 /* If there is no note name, then use the default set of
15614 note type strings. */
15615 nt = get_note_type (pnote->type);
15616
1118d252
RM		 15617 else if (const_strneq (pnote->namedata, "GNU"))
15618 /* GNU-specific object file notes. */
15619 nt = get_gnu_elf_note_type (pnote->type);
15620
0112cd26 15621 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15622 /* NetBSD-specific core file notes. */
15623 nt = get_netbsd_elfcore_note_type (pnote->type);
15624
c6056a74
SF		 15625 else if (const_strneq (pnote->namedata, "NetBSD"))
15626 /* NetBSD-specific core file notes. */
15627 return process_netbsd_elf_note (pnote);
15628
b15fa79e
AM		 15629 else if (strneq (pnote->namedata, "SPU/", 4))
15630 {
15631 /* SPU-specific core file notes. */
15632 nt = pnote->namedata + 4;
15633 name = "SPU";
15634 }
15635
00e98fc7
TG		 15636 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15637 /* VMS/ia64-specific file notes. */
15638 nt = get_ia64_vms_note_type (pnote->type);
15639
70616151
TT		 15640 else if (const_strneq (pnote->namedata, "stapsdt"))
15641 nt = get_stapsdt_note_type (pnote->type);
15642
9437c45b 15643 else
1ec5cd37
NC		 15644 /* Don't recognize this note name; just use the default set of
15645 note type strings. */
00e98fc7 15646 nt = get_note_type (pnote->type);
9437c45b 15647
2aee03ae 15648 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15649
15650 if (const_strneq (pnote->namedata, "IPF/VMS"))
15651 return print_ia64_vms_note (pnote);
664f90a3
TT		 15652 else if (const_strneq (pnote->namedata, "GNU"))
15653 return print_gnu_note (pnote);
c6a9fc58
TT		 15654 else if (const_strneq (pnote->namedata, "stapsdt"))
15655 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15656 else if (const_strneq (pnote->namedata, "CORE"))
15657 return print_core_note (pnote);
00e98fc7
TG		 15658 else
15659 return 1;
779fe533
NC		 15660}
15661
6d118b09 15662
779fe533 15663static int
2cf0635d 15664process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15665{
2cf0635d
NC		 15666 Elf_External_Note * pnotes;
15667 Elf_External_Note * external;
c8071705 15668 char * end;
b34976b6 15669 int res = 1;
103f02d3 15670
779fe533
NC		 15671 if (length <= 0)
15672 return 0;
103f02d3 15673
3f5e193b 15674 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15675 _("notes"));
dd24e3da 15676 if (pnotes == NULL)
a6e9f9df 15677 return 0;
779fe533 15678
103f02d3 15679 external = pnotes;
103f02d3 15680
9dd3a467 15681 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15682 (unsigned long) offset, (unsigned long) length);
2aee03ae 15683 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15684
c8071705
NC		 15685 end = (char *) pnotes + length;
15686 while ((char *) external < end)
779fe533 15687 {
b34976b6 15688 Elf_Internal_Note inote;
15b42fb0
AM		 15689 size_t min_notesz;
15690 char *next;
2cf0635d 15691 char * temp = NULL;
c8071705 15692 size_t data_remaining = end - (char *) external;
6d118b09 15693
00e98fc7 15694 if (!is_ia64_vms ())
15b42fb0 15695 {
9dd3a467
NC		 15696 /* PR binutils/15191
15697 Make sure that there is enough data to read. */
15b42fb0
AM		 15698 min_notesz = offsetof (Elf_External_Note, name);
15699 if (data_remaining < min_notesz)
9dd3a467
NC		 15700 {
15701 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15702 (int) data_remaining);
15703 break;
15704 }
15b42fb0
AM		 15705 inote.type = BYTE_GET (external->type);
15706 inote.namesz = BYTE_GET (external->namesz);
15707 inote.namedata = external->name;
15708 inote.descsz = BYTE_GET (external->descsz);
15709 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15710 /* PR 17531: file: 3443835e. */
c8071705 15711 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15712 {
15713 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15714 inote.descdata = inote.namedata;
15715 inote.namesz = 0;
15716 }
14ae95f2 15717
15b42fb0
AM		 15718 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15719 next = inote.descdata + align_power (inote.descsz, 2);
15720 }
00e98fc7 15721 else
15b42fb0
AM		 15722 {
15723 Elf64_External_VMS_Note *vms_external;
00e98fc7 15724
9dd3a467
NC		 15725 /* PR binutils/15191
15726 Make sure that there is enough data to read. */
15b42fb0
AM		 15727 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15728 if (data_remaining < min_notesz)
9dd3a467
NC		 15729 {
15730 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15731 (int) data_remaining);
15732 break;
15733 }
3e55a963 15734
15b42fb0
AM		 15735 vms_external = (Elf64_External_VMS_Note *) external;
15736 inote.type = BYTE_GET (vms_external->type);
15737 inote.namesz = BYTE_GET (vms_external->namesz);
15738 inote.namedata = vms_external->name;
15739 inote.descsz = BYTE_GET (vms_external->descsz);
15740 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15741 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15742 next = inote.descdata + align_power (inote.descsz, 3);
15743 }
15744
15745 if (inote.descdata < (char *) external + min_notesz
15746 || next < (char *) external + min_notesz
5d921cbd
NC		 15747 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15748 || inote.namedata + inote.namesz < inote.namedata
15749 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15750 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15751 {
15b42fb0 15752 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15753 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15754 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15755 inote.type, inote.namesz, inote.descsz);
15756 break;
15757 }
15758
15b42fb0 15759 external = (Elf_External_Note *) next;
dd24e3da 15760
6d118b09
NC		 15761 /* Verify that name is null terminated. It appears that at least
15762 one version of Linux (RedHat 6.0) generates corefiles that don't
15763 comply with the ELF spec by failing to include the null byte in
15764 namesz. */
8b971f9f 15765 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15766 {
3f5e193b 15767 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15768 if (temp == NULL)
15769 {
8b73c356 15770 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15771 res = 0;
15772 break;
15773 }
76da6bbe 15774
6d118b09
NC		 15775 strncpy (temp, inote.namedata, inote.namesz);
15776 temp[inote.namesz] = 0;
76da6bbe 15777
6d118b09
NC		 15778 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15779 inote.namedata = temp;
15780 }
15781
15782 res &= process_note (& inote);
103f02d3 15783
6d118b09
NC		 15784 if (temp != NULL)
15785 {
15786 free (temp);
15787 temp = NULL;
15788 }
779fe533
NC		 15789 }
15790
15791 free (pnotes);
103f02d3 15792
779fe533
NC		 15793 return res;
15794}
15795
15796static int
2cf0635d 15797process_corefile_note_segments (FILE * file)
779fe533 15798{
2cf0635d 15799 Elf_Internal_Phdr * segment;
b34976b6
AM		 15800 unsigned int i;
15801 int res = 1;
103f02d3 15802
d93f0186 15803 if (! get_program_headers (file))
779fe533 15804 return 0;
103f02d3 15805
779fe533
NC		 15806 for (i = 0, segment = program_headers;
15807 i < elf_header.e_phnum;
b34976b6 15808 i++, segment++)
779fe533
NC		 15809 {
15810 if (segment->p_type == PT_NOTE)
103f02d3 15811 res &= process_corefile_note_segment (file,
30800947
NC		 15812 (bfd_vma) segment->p_offset,
15813 (bfd_vma) segment->p_filesz);
779fe533 15814 }
103f02d3 15815
779fe533
NC		 15816 return res;
15817}
15818
685080f2
NC		 15819static int
15820process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15821{
15822 Elf_External_Note * pnotes;
15823 Elf_External_Note * external;
c8071705 15824 char * end;
685080f2
NC		 15825 int res = 1;
15826
15827 if (length <= 0)
15828 return 0;
15829
15830 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15831 _("v850 notes"));
15832 if (pnotes == NULL)
15833 return 0;
15834
15835 external = pnotes;
c8071705 15836 end = (char*) pnotes + length;
685080f2
NC		 15837
15838 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15839 (unsigned long) offset, (unsigned long) length);
15840
c8071705 15841 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15842 {
15843 Elf_External_Note * next;
15844 Elf_Internal_Note inote;
15845
15846 inote.type = BYTE_GET (external->type);
15847 inote.namesz = BYTE_GET (external->namesz);
15848 inote.namedata = external->name;
15849 inote.descsz = BYTE_GET (external->descsz);
15850 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15851 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15852
c8071705
NC		 15853 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15854 {
15855 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15856 inote.descdata = inote.namedata;
15857 inote.namesz = 0;
15858 }
15859
685080f2
NC		 15860 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15861
c8071705 15862 if ( ((char *) next > end)
685080f2
NC		 15863 || ((char *) next < (char *) pnotes))
15864 {
15865 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15866 (unsigned long) ((char *) external - (char *) pnotes));
15867 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15868 inote.type, inote.namesz, inote.descsz);
15869 break;
15870 }
15871
15872 external = next;
15873
15874 /* Prevent out-of-bounds indexing. */
c8071705 15875 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15876 || inote.namedata + inote.namesz < inote.namedata)
15877 {
15878 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15879 (unsigned long) ((char *) external - (char *) pnotes));
15880 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15881 inote.type, inote.namesz, inote.descsz);
15882 break;
15883 }
15884
15885 printf (" %s: ", get_v850_elf_note_type (inote.type));
15886
15887 if (! print_v850_note (& inote))
15888 {
15889 res = 0;
15890 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15891 inote.namesz, inote.descsz);
15892 }
15893 }
15894
15895 free (pnotes);
15896
15897 return res;
15898}
15899
779fe533 15900static int
2cf0635d 15901process_note_sections (FILE * file)
1ec5cd37 15902{
2cf0635d 15903 Elf_Internal_Shdr * section;
1ec5cd37 15904 unsigned long i;
df565f32 15905 int n = 0;
1ec5cd37
NC		 15906 int res = 1;
15907
15908 for (i = 0, section = section_headers;
fa1908fd 15909 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15910 i++, section++)
685080f2
NC		 15911 {
15912 if (section->sh_type == SHT_NOTE)
15913 {
15914 res &= process_corefile_note_segment (file,
15915 (bfd_vma) section->sh_offset,
15916 (bfd_vma) section->sh_size);
15917 n++;
15918 }
15919
15920 if (( elf_header.e_machine == EM_V800
15921 || elf_header.e_machine == EM_V850
15922 || elf_header.e_machine == EM_CYGNUS_V850)
15923 && section->sh_type == SHT_RENESAS_INFO)
15924 {
15925 res &= process_v850_notes (file,
15926 (bfd_vma) section->sh_offset,
15927 (bfd_vma) section->sh_size);
15928 n++;
15929 }
15930 }
df565f32
NC		 15931
15932 if (n == 0)
15933 /* Try processing NOTE segments instead. */
15934 return process_corefile_note_segments (file);
1ec5cd37
NC		 15935
15936 return res;
15937}
15938
15939static int
2cf0635d 15940process_notes (FILE * file)
779fe533
NC		 15941{
15942 /* If we have not been asked to display the notes then do nothing. */
15943 if (! do_notes)
15944 return 1;
103f02d3 15945
779fe533 15946 if (elf_header.e_type != ET_CORE)
1ec5cd37 15947 return process_note_sections (file);
103f02d3 15948
779fe533 15949 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15950 if (elf_header.e_phnum > 0)
15951 return process_corefile_note_segments (file);
779fe533 15952
1ec5cd37
NC		 15953 printf (_("No note segments present in the core file.\n"));
15954 return 1;
779fe533
NC		 15955}
15956
252b5132 15957static int
2cf0635d 15958process_arch_specific (FILE * file)
252b5132 15959{
a952a375
NC		 15960 if (! do_arch)
15961 return 1;
15962
252b5132
RH		 15963 switch (elf_header.e_machine)
15964 {
11c1ff18
PB		 15965 case EM_ARM:
15966 return process_arm_specific (file);
252b5132 15967 case EM_MIPS:
4fe85591 15968 case EM_MIPS_RS3_LE:
252b5132
RH		 15969 return process_mips_specific (file);
15970 break;
35c08157
KLC		 15971 case EM_NDS32:
15972 return process_nds32_specific (file);
15973 break;
34c8bcba
JM		 15974 case EM_PPC:
15975 return process_power_specific (file);
15976 break;
643f7afb
AK		 15977 case EM_S390:
15978 case EM_S390_OLD:
15979 return process_s390_specific (file);
15980 break;
9e8c70f9
DM		 15981 case EM_SPARC:
15982 case EM_SPARC32PLUS:
15983 case EM_SPARCV9:
15984 return process_sparc_specific (file);
15985 break;
59e6276b
JM		 15986 case EM_TI_C6000:
15987 return process_tic6x_specific (file);
15988 break;
13761a11
NC		 15989 case EM_MSP430:
15990 return process_msp430x_specific (file);
252b5132
RH		 15991 default:
15992 break;
15993 }
15994 return 1;
15995}
15996
15997static int
2cf0635d 15998get_file_header (FILE * file)
252b5132 15999{
9ea033b2
NC		 16000 /* Read in the identity array. */
16001 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16002 return 0;
16003
9ea033b2 16004 /* Determine how to read the rest of the header. */
b34976b6 16005 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16006 {
16007 default: /* fall through */
16008 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16009 case ELFDATA2LSB:
16010 byte_get = byte_get_little_endian;
16011 byte_put = byte_put_little_endian;
16012 break;
16013 case ELFDATA2MSB:
16014 byte_get = byte_get_big_endian;
16015 byte_put = byte_put_big_endian;
16016 break;
9ea033b2
NC		 16017 }
16018
16019 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16020 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16021
16022 /* Read in the rest of the header. */
16023 if (is_32bit_elf)
16024 {
16025 Elf32_External_Ehdr ehdr32;
252b5132 16026
9ea033b2
NC		 16027 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16028 return 0;
103f02d3 16029
9ea033b2
NC		 16030 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16031 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16032 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16033 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16034 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16035 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16036 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16037 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16038 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16039 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16040 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16041 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16042 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16043 }
252b5132 16044 else
9ea033b2
NC		 16045 {
16046 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16047
16048 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16049 we will not be able to cope with the 64bit data found in
16050 64 ELF files. Detect this now and abort before we start
50c2245b 16051 overwriting things. */
a952a375
NC		 16052 if (sizeof (bfd_vma) < 8)
16053 {
e3c8793a
NC		 16054 error (_("This instance of readelf has been built without support for a\n\
1605564 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16056 return 0;
16057 }
103f02d3 16058
9ea033b2
NC		 16059 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16060 return 0;
103f02d3 16061
9ea033b2
NC		 16062 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16063 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16064 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16065 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16066 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16067 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16068 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16069 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16070 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16071 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16072 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16073 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16074 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16075 }
252b5132 16076
7ece0d85
JJ		 16077 if (elf_header.e_shoff)
16078 {
16079 /* There may be some extensions in the first section header. Don't
16080 bomb if we can't read it. */
16081 if (is_32bit_elf)
049b0c3a 16082 get_32bit_section_headers (file, TRUE);
7ece0d85 16083 else
049b0c3a 16084 get_64bit_section_headers (file, TRUE);
7ece0d85 16085 }
560f3c1c 16086
252b5132
RH		 16087 return 1;
16088}
16089
fb52b2f4
NC		 16090/* Process one ELF object file according to the command line options.
16091 This file may actually be stored in an archive. The file is
16092 positioned at the start of the ELF object. */
16093
ff78d6d6 16094static int
2cf0635d 16095process_object (char * file_name, FILE * file)
252b5132 16096{
252b5132
RH		 16097 unsigned int i;
16098
252b5132
RH		 16099 if (! get_file_header (file))
16100 {
16101 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16102 return 1;
252b5132
RH		 16103 }
16104
16105 /* Initialise per file variables. */
60bca95a 16106 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16107 version_info[i] = 0;
16108
60bca95a 16109 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16110 dynamic_info[i] = 0;
5115b233 16111 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16112
16113 /* Process the file. */
16114 if (show_name)
16115 printf (_("\nFile: %s\n"), file_name);
16116
18bd398b
NC		 16117 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16118 Note we do this even if cmdline_dump_sects is empty because we
16119 must make sure that the dump_sets array is zeroed out before each
16120 object file is processed. */
16121 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16122 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16123
16124 if (num_cmdline_dump_sects > 0)
16125 {
16126 if (num_dump_sects == 0)
16127 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16128 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16129
16130 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16131 memcpy (dump_sects, cmdline_dump_sects,
16132 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16133 }
d70c5fc7 16134
252b5132 16135 if (! process_file_header ())
fb52b2f4 16136 return 1;
252b5132 16137
d1f5c6e3 16138 if (! process_section_headers (file))
2f62977e 16139 {
d1f5c6e3
L		 16140 /* Without loaded section headers we cannot process lots of
16141 things. */
2f62977e 16142 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16143
2f62977e 16144 if (! do_using_dynamic)
2c610e4b 16145 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16146 }
252b5132 16147
d1f5c6e3
L		 16148 if (! process_section_groups (file))
16149 {
16150 /* Without loaded section groups we cannot process unwind. */
16151 do_unwind = 0;
16152 }
16153
2f62977e 16154 if (process_program_headers (file))
b2d38a17 16155 process_dynamic_section (file);
252b5132
RH		 16156
16157 process_relocs (file);
16158
4d6ed7c8
NC		 16159 process_unwind (file);
16160
252b5132
RH		 16161 process_symbol_table (file);
16162
16163 process_syminfo (file);
16164
16165 process_version_sections (file);
16166
16167 process_section_contents (file);
f5842774 16168
1ec5cd37 16169 process_notes (file);
103f02d3 16170
047b2264
JJ		 16171 process_gnu_liblist (file);
16172
252b5132
RH		 16173 process_arch_specific (file);
16174
d93f0186
NC		 16175 if (program_headers)
16176 {
16177 free (program_headers);
16178 program_headers = NULL;
16179 }
16180
252b5132
RH		 16181 if (section_headers)
16182 {
16183 free (section_headers);
16184 section_headers = NULL;
16185 }
16186
16187 if (string_table)
16188 {
16189 free (string_table);
16190 string_table = NULL;
d40ac9bd 16191 string_table_length = 0;
252b5132
RH		 16192 }
16193
16194 if (dynamic_strings)
16195 {
16196 free (dynamic_strings);
16197 dynamic_strings = NULL;
d79b3d50 16198 dynamic_strings_length = 0;
252b5132
RH		 16199 }
16200
16201 if (dynamic_symbols)
16202 {
16203 free (dynamic_symbols);
16204 dynamic_symbols = NULL;
19936277 16205 num_dynamic_syms = 0;
252b5132
RH		 16206 }
16207
16208 if (dynamic_syminfo)
16209 {
16210 free (dynamic_syminfo);
16211 dynamic_syminfo = NULL;
16212 }
ff78d6d6 16213
293c573e
MR		 16214 if (dynamic_section)
16215 {
16216 free (dynamic_section);
16217 dynamic_section = NULL;
16218 }
16219
e4b17d5c
L		 16220 if (section_headers_groups)
16221 {
16222 free (section_headers_groups);
16223 section_headers_groups = NULL;
16224 }
16225
16226 if (section_groups)
16227 {
2cf0635d
NC		 16228 struct group_list * g;
16229 struct group_list * next;
e4b17d5c
L		 16230
16231 for (i = 0; i < group_count; i++)
16232 {
16233 for (g = section_groups [i].root; g != NULL; g = next)
16234 {
16235 next = g->next;
16236 free (g);
16237 }
16238 }
16239
16240 free (section_groups);
16241 section_groups = NULL;
16242 }
16243
19e6b90e 16244 free_debug_memory ();
18bd398b 16245
ff78d6d6 16246 return 0;
252b5132
RH		 16247}
16248
2cf0635d
NC		 16249/* Process an ELF archive.
16250 On entry the file is positioned just after the ARMAG string. */
16251
16252static int
16253process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16254{
16255 struct archive_info arch;
16256 struct archive_info nested_arch;
16257 size_t got;
2cf0635d
NC		 16258 int ret;
16259
16260 show_name = 1;
16261
16262 /* The ARCH structure is used to hold information about this archive. */
16263 arch.file_name = NULL;
16264 arch.file = NULL;
16265 arch.index_array = NULL;
16266 arch.sym_table = NULL;
16267 arch.longnames = NULL;
16268
16269 /* The NESTED_ARCH structure is used as a single-item cache of information
16270 about a nested archive (when members of a thin archive reside within
16271 another regular archive file). */
16272 nested_arch.file_name = NULL;
16273 nested_arch.file = NULL;
16274 nested_arch.index_array = NULL;
16275 nested_arch.sym_table = NULL;
16276 nested_arch.longnames = NULL;
16277
16278 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16279 {
16280 ret = 1;
16281 goto out;
4145f1d5 16282 }
fb52b2f4 16283
4145f1d5
NC		 16284 if (do_archive_index)
16285 {
2cf0635d 16286 if (arch.sym_table == NULL)
4145f1d5
NC		 16287 error (_("%s: unable to dump the index as none was found\n"), file_name);
16288 else
16289 {
591f7597 16290 unsigned long i, l;
4145f1d5
NC		 16291 unsigned long current_pos;
16292
591f7597
NC		 16293 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16294 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16295 current_pos = ftell (file);
16296
2cf0635d 16297 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16298 {
2cf0635d
NC		 16299 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16300 {
16301 char * member_name;
4145f1d5 16302
2cf0635d
NC		 16303 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16304
16305 if (member_name != NULL)
16306 {
16307 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16308
16309 if (qualified_name != NULL)
16310 {
c2a7d3f5
NC		 16311 printf (_("Contents of binary %s at offset "), qualified_name);
16312 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16313 putchar ('\n');
2cf0635d
NC		 16314 free (qualified_name);
16315 }
4145f1d5
NC		 16316 }
16317 }
2cf0635d
NC		 16318
16319 if (l >= arch.sym_size)
4145f1d5
NC		 16320 {
16321 error (_("%s: end of the symbol table reached before the end of the index\n"),
16322 file_name);
cb8f3167 16323 break;
4145f1d5 16324 }
591f7597
NC		 16325 /* PR 17531: file: 0b6630b2. */
16326 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16327 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16328 }
16329
c2a7d3f5
NC		 16330 if (arch.uses_64bit_indicies)
16331 l = (l + 7) & ~ 7;
16332 else
16333 l += l & 1;
16334
2cf0635d 16335 if (l < arch.sym_size)
c2a7d3f5
NC		 16336 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16337 file_name, arch.sym_size - l);
4145f1d5 16338
4145f1d5
NC		 16339 if (fseek (file, current_pos, SEEK_SET) != 0)
16340 {
16341 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16342 ret = 1;
16343 goto out;
4145f1d5 16344 }
fb52b2f4 16345 }
4145f1d5
NC		 16346
16347 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16348 && !do_segments && !do_header && !do_dump && !do_version
16349 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16350 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16351 {
16352 ret = 0; /* Archive index only. */
16353 goto out;
16354 }
fb52b2f4
NC		 16355 }
16356
d989285c 16357 ret = 0;
fb52b2f4
NC		 16358
16359 while (1)
16360 {
2cf0635d
NC		 16361 char * name;
16362 size_t namelen;
16363 char * qualified_name;
16364
16365 /* Read the next archive header. */
16366 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16367 {
16368 error (_("%s: failed to seek to next archive header\n"), file_name);
16369 return 1;
16370 }
16371 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16372 if (got != sizeof arch.arhdr)
16373 {
16374 if (got == 0)
16375 break;
16376 error (_("%s: failed to read archive header\n"), file_name);
16377 ret = 1;
16378 break;
16379 }
16380 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16381 {
16382 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16383 ret = 1;
16384 break;
16385 }
16386
16387 arch.next_arhdr_offset += sizeof arch.arhdr;
16388
16389 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16390 if (archive_file_size & 01)
16391 ++archive_file_size;
16392
16393 name = get_archive_member_name (&arch, &nested_arch);
16394 if (name == NULL)
fb52b2f4 16395 {
0fd3a477 16396 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16397 ret = 1;
16398 break;
fb52b2f4 16399 }
2cf0635d 16400 namelen = strlen (name);
fb52b2f4 16401
2cf0635d
NC		 16402 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16403 if (qualified_name == NULL)
fb52b2f4 16404 {
2cf0635d 16405 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16406 ret = 1;
16407 break;
fb52b2f4
NC		 16408 }
16409
2cf0635d
NC		 16410 if (is_thin_archive && arch.nested_member_origin == 0)
16411 {
16412 /* This is a proxy for an external member of a thin archive. */
16413 FILE * member_file;
16414 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16415 if (member_file_name == NULL)
16416 {
16417 ret = 1;
16418 break;
16419 }
16420
16421 member_file = fopen (member_file_name, "rb");
16422 if (member_file == NULL)
16423 {
16424 error (_("Input file '%s' is not readable.\n"), member_file_name);
16425 free (member_file_name);
16426 ret = 1;
16427 break;
16428 }
16429
16430 archive_file_offset = arch.nested_member_origin;
16431
16432 ret |= process_object (qualified_name, member_file);
16433
16434 fclose (member_file);
16435 free (member_file_name);
16436 }
16437 else if (is_thin_archive)
16438 {
a043396b
NC		 16439 /* PR 15140: Allow for corrupt thin archives. */
16440 if (nested_arch.file == NULL)
16441 {
16442 error (_("%s: contains corrupt thin archive: %s\n"),
16443 file_name, name);
16444 ret = 1;
16445 break;
16446 }
16447
2cf0635d
NC		 16448 /* This is a proxy for a member of a nested archive. */
16449 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16450
16451 /* The nested archive file will have been opened and setup by
16452 get_archive_member_name. */
16453 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16454 {
16455 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16456 ret = 1;
16457 break;
16458 }
16459
16460 ret |= process_object (qualified_name, nested_arch.file);
16461 }
16462 else
16463 {
16464 archive_file_offset = arch.next_arhdr_offset;
16465 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16466
2cf0635d
NC		 16467 ret |= process_object (qualified_name, file);
16468 }
fb52b2f4 16469
2b52916e
L		 16470 if (dump_sects != NULL)
16471 {
16472 free (dump_sects);
16473 dump_sects = NULL;
16474 num_dump_sects = 0;
16475 }
16476
2cf0635d 16477 free (qualified_name);
fb52b2f4
NC		 16478 }
16479
4145f1d5 16480 out:
2cf0635d
NC		 16481 if (nested_arch.file != NULL)
16482 fclose (nested_arch.file);
16483 release_archive (&nested_arch);
16484 release_archive (&arch);
fb52b2f4 16485
d989285c 16486 return ret;
fb52b2f4
NC		 16487}
16488
16489static int
2cf0635d 16490process_file (char * file_name)
fb52b2f4 16491{
2cf0635d 16492 FILE * file;
fb52b2f4
NC		 16493 struct stat statbuf;
16494 char armag[SARMAG];
16495 int ret;
16496
16497 if (stat (file_name, &statbuf) < 0)
16498 {
f24ddbdd
NC		 16499 if (errno == ENOENT)
16500 error (_("'%s': No such file\n"), file_name);
16501 else
16502 error (_("Could not locate '%s'. System error message: %s\n"),
16503 file_name, strerror (errno));
16504 return 1;
16505 }
16506
16507 if (! S_ISREG (statbuf.st_mode))
16508 {
16509 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16510 return 1;
16511 }
16512
16513 file = fopen (file_name, "rb");
16514 if (file == NULL)
16515 {
f24ddbdd 16516 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16517 return 1;
16518 }
16519
16520 if (fread (armag, SARMAG, 1, file) != 1)
16521 {
4145f1d5 16522 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16523 fclose (file);
16524 return 1;
16525 }
16526
f54498b4
NC		 16527 current_file_size = (bfd_size_type) statbuf.st_size;
16528
fb52b2f4 16529 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16530 ret = process_archive (file_name, file, FALSE);
16531 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16532 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16533 else
16534 {
4145f1d5
NC		 16535 if (do_archive_index)
16536 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16537 file_name);
16538
fb52b2f4
NC		 16539 rewind (file);
16540 archive_file_size = archive_file_offset = 0;
16541 ret = process_object (file_name, file);
16542 }
16543
16544 fclose (file);
16545
f54498b4 16546 current_file_size = 0;
fb52b2f4
NC		 16547 return ret;
16548}
16549
252b5132
RH		 16550#ifdef SUPPORT_DISASSEMBLY
16551/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16552 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16553 symbols. */
252b5132
RH		 16554
16555void
2cf0635d 16556print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16557{
16558 fprintf (outfile,"0x%8.8x", addr);
16559}
16560
e3c8793a 16561/* Needed by the i386 disassembler. */
252b5132
RH		 16562void
16563db_task_printsym (unsigned int addr)
16564{
16565 print_address (addr, stderr);
16566}
16567#endif
16568
16569int
2cf0635d 16570main (int argc, char ** argv)
252b5132 16571{
ff78d6d6
L		 16572 int err;
16573
252b5132
RH		 16574#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16575 setlocale (LC_MESSAGES, "");
3882b010
L		 16576#endif
16577#if defined (HAVE_SETLOCALE)
16578 setlocale (LC_CTYPE, "");
252b5132
RH		 16579#endif
16580 bindtextdomain (PACKAGE, LOCALEDIR);
16581 textdomain (PACKAGE);
16582
869b9d07
MM		 16583 expandargv (&argc, &argv);
16584
252b5132
RH		 16585 parse_args (argc, argv);
16586
18bd398b 16587 if (num_dump_sects > 0)
59f14fc0 16588 {
18bd398b 16589 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16590 cmdline_dump_sects = (dump_type *)
16591 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16592 if (cmdline_dump_sects == NULL)
591a748a 16593 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16594 else
16595 {
09c11c86
NC		 16596 memcpy (cmdline_dump_sects, dump_sects,
16597 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16598 num_cmdline_dump_sects = num_dump_sects;
16599 }
16600 }
16601
18bd398b
NC		 16602 if (optind < (argc - 1))
16603 show_name = 1;
5656ba2c
L		 16604 else if (optind >= argc)
16605 {
16606 warn (_("Nothing to do.\n"));
16607 usage (stderr);
16608 }
18bd398b 16609
ff78d6d6 16610 err = 0;
252b5132 16611 while (optind < argc)
18bd398b 16612 err |= process_file (argv[optind++]);
252b5132
RH		 16613
16614 if (dump_sects != NULL)
16615 free (dump_sects);
59f14fc0
AS		 16616 if (cmdline_dump_sects != NULL)
16617 free (cmdline_dump_sects);
252b5132 16618
ff78d6d6 16619 return err;
252b5132 16620}
GDB Binutils - Deliverables
This page took 2.275387 seconds and 4 git commands to generate.