]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add an expect for running commands with CLI jump
[thirdparty/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");
a117b0a5
YS		 3379 if (e_flags & E_FLAG_RX_V2)
3380 strcat (buf, ", V2");
d4cb0ea0 3381 break;
55786da2
AK		 3382
3383 case EM_S390:
3384 if (e_flags & EF_S390_HIGH_GPRS)
3385 strcat (buf, ", highgprs");
d4cb0ea0 3386 break;
40b36596
JM		 3387
3388 case EM_TI_C6000:
3389 if ((e_flags & EF_C6000_REL))
3390 strcat (buf, ", relocatable module");
d4cb0ea0 3391 break;
13761a11
NC		 3392
3393 case EM_MSP430:
3394 strcat (buf, _(": architecture variant: "));
3395 switch (e_flags & EF_MSP430_MACH)
3396 {
3397 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3398 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3399 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3400 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3401 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3402 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3403 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3404 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3405 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3406 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3407 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3408 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3409 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3410 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3411 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3412 default:
3413 strcat (buf, _(": unknown")); break;
3414 }
3415
3416 if (e_flags & ~ EF_MSP430_MACH)
3417 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3418 }
3419 }
3420
3421 return buf;
3422}
3423
252b5132 3424static const char *
d3ba0551
AM		 3425get_osabi_name (unsigned int osabi)
3426{
3427 static char buff[32];
3428
3429 switch (osabi)
3430 {
3431 case ELFOSABI_NONE: return "UNIX - System V";
3432 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3433 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3434 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3435 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3436 case ELFOSABI_AIX: return "UNIX - AIX";
3437 case ELFOSABI_IRIX: return "UNIX - IRIX";
3438 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3439 case ELFOSABI_TRU64: return "UNIX - TRU64";
3440 case ELFOSABI_MODESTO: return "Novell - Modesto";
3441 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3442 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3443 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3444 case ELFOSABI_AROS: return "AROS";
11636f9e 3445 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3446 default:
40b36596
JM		 3447 if (osabi >= 64)
3448 switch (elf_header.e_machine)
3449 {
3450 case EM_ARM:
3451 switch (osabi)
3452 {
3453 case ELFOSABI_ARM: return "ARM";
3454 default:
3455 break;
3456 }
3457 break;
3458
3459 case EM_MSP430:
3460 case EM_MSP430_OLD:
619ed720 3461 case EM_VISIUM:
40b36596
JM		 3462 switch (osabi)
3463 {
3464 case ELFOSABI_STANDALONE: return _("Standalone App");
3465 default:
3466 break;
3467 }
3468 break;
3469
3470 case EM_TI_C6000:
3471 switch (osabi)
3472 {
3473 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3474 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3475 default:
3476 break;
3477 }
3478 break;
3479
3480 default:
3481 break;
3482 }
e9e44622 3483 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3484 return buff;
3485 }
3486}
3487
a06ea964
NC		 3488static const char *
3489get_aarch64_segment_type (unsigned long type)
3490{
3491 switch (type)
3492 {
3493 case PT_AARCH64_ARCHEXT:
3494 return "AARCH64_ARCHEXT";
3495 default:
3496 break;
3497 }
3498
3499 return NULL;
3500}
3501
b294bdf8
MM		 3502static const char *
3503get_arm_segment_type (unsigned long type)
3504{
3505 switch (type)
3506 {
3507 case PT_ARM_EXIDX:
3508 return "EXIDX";
3509 default:
3510 break;
3511 }
3512
3513 return NULL;
3514}
3515
d3ba0551
AM		 3516static const char *
3517get_mips_segment_type (unsigned long type)
252b5132
RH		 3518{
3519 switch (type)
3520 {
3521 case PT_MIPS_REGINFO:
3522 return "REGINFO";
3523 case PT_MIPS_RTPROC:
3524 return "RTPROC";
3525 case PT_MIPS_OPTIONS:
3526 return "OPTIONS";
351cdf24
MF		 3527 case PT_MIPS_ABIFLAGS:
3528 return "ABIFLAGS";
252b5132
RH		 3529 default:
3530 break;
3531 }
3532
3533 return NULL;
3534}
3535
103f02d3 3536static const char *
d3ba0551 3537get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3538{
3539 switch (type)
3540 {
3541 case PT_HP_TLS: return "HP_TLS";
3542 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3543 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3544 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3545 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3546 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3547 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3548 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3549 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3550 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3551 case PT_HP_PARALLEL: return "HP_PARALLEL";
3552 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3553 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3554 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3555 case PT_HP_STACK: return "HP_STACK";
3556 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3557 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3558 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3559 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3560 default:
3561 break;
3562 }
3563
3564 return NULL;
3565}
3566
4d6ed7c8 3567static const char *
d3ba0551 3568get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3569{
3570 switch (type)
3571 {
3572 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3573 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3574 case PT_HP_TLS: return "HP_TLS";
3575 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3576 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3577 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3578 default:
3579 break;
3580 }
3581
3582 return NULL;
3583}
3584
40b36596
JM		 3585static const char *
3586get_tic6x_segment_type (unsigned long type)
3587{
3588 switch (type)
3589 {
3590 case PT_C6000_PHATTR: return "C6000_PHATTR";
3591 default:
3592 break;
3593 }
3594
3595 return NULL;
3596}
3597
252b5132 3598static const char *
d3ba0551 3599get_segment_type (unsigned long p_type)
252b5132 3600{
b34976b6 3601 static char buff[32];
252b5132
RH		 3602
3603 switch (p_type)
3604 {
b34976b6
AM		 3605 case PT_NULL: return "NULL";
3606 case PT_LOAD: return "LOAD";
252b5132 3607 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3608 case PT_INTERP: return "INTERP";
3609 case PT_NOTE: return "NOTE";
3610 case PT_SHLIB: return "SHLIB";
3611 case PT_PHDR: return "PHDR";
13ae64f3 3612 case PT_TLS: return "TLS";
252b5132 3613
65765700
JJ		 3614 case PT_GNU_EH_FRAME:
3615 return "GNU_EH_FRAME";
2b05f1b7 3616 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3617 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3618
252b5132
RH		 3619 default:
3620 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3621 {
2cf0635d 3622 const char * result;
103f02d3 3623
252b5132
RH		 3624 switch (elf_header.e_machine)
3625 {
a06ea964
NC		 3626 case EM_AARCH64:
3627 result = get_aarch64_segment_type (p_type);
3628 break;
b294bdf8
MM		 3629 case EM_ARM:
3630 result = get_arm_segment_type (p_type);
3631 break;
252b5132 3632 case EM_MIPS:
4fe85591 3633 case EM_MIPS_RS3_LE:
252b5132
RH		 3634 result = get_mips_segment_type (p_type);
3635 break;
103f02d3
UD		 3636 case EM_PARISC:
3637 result = get_parisc_segment_type (p_type);
3638 break;
4d6ed7c8
NC		 3639 case EM_IA_64:
3640 result = get_ia64_segment_type (p_type);
3641 break;
40b36596
JM		 3642 case EM_TI_C6000:
3643 result = get_tic6x_segment_type (p_type);
3644 break;
252b5132
RH		 3645 default:
3646 result = NULL;
3647 break;
3648 }
103f02d3 3649
252b5132
RH		 3650 if (result != NULL)
3651 return result;
103f02d3 3652
252b5132
RH		 3653 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3654 }
3655 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3656 {
2cf0635d 3657 const char * result;
103f02d3
UD		 3658
3659 switch (elf_header.e_machine)
3660 {
3661 case EM_PARISC:
3662 result = get_parisc_segment_type (p_type);
3663 break;
00428cca
AM		 3664 case EM_IA_64:
3665 result = get_ia64_segment_type (p_type);
3666 break;
103f02d3
UD		 3667 default:
3668 result = NULL;
3669 break;
3670 }
3671
3672 if (result != NULL)
3673 return result;
3674
3675 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3676 }
252b5132 3677 else
e9e44622 3678 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3679
3680 return buff;
3681 }
3682}
3683
3684static const char *
d3ba0551 3685get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3686{
3687 switch (sh_type)
3688 {
b34976b6
AM		 3689 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3690 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3691 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3692 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3693 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3694 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3695 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3696 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3697 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3698 case SHT_MIPS_RELD: return "MIPS_RELD";
3699 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3700 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3701 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3702 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3703 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3704 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3705 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3706 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3707 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3708 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3709 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3710 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3711 case SHT_MIPS_LINE: return "MIPS_LINE";
3712 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3713 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3714 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3715 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3716 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3717 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3718 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3719 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3720 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3721 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3722 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3723 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3724 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3725 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3726 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3727 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3728 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3729 default:
3730 break;
3731 }
3732 return NULL;
3733}
3734
103f02d3 3735static const char *
d3ba0551 3736get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3737{
3738 switch (sh_type)
3739 {
3740 case SHT_PARISC_EXT: return "PARISC_EXT";
3741 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3742 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3743 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3744 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3745 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3746 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3747 default:
3748 break;
3749 }
3750 return NULL;
3751}
3752
4d6ed7c8 3753static const char *
d3ba0551 3754get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3755{
18bd398b 3756 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3757 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3758 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3759
4d6ed7c8
NC		 3760 switch (sh_type)
3761 {
148b93f2
NC		 3762 case SHT_IA_64_EXT: return "IA_64_EXT";
3763 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3764 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3765 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3766 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3767 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3768 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3769 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3770 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3771 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3772 default:
3773 break;
3774 }
3775 return NULL;
3776}
3777
d2b2c203
DJ		 3778static const char *
3779get_x86_64_section_type_name (unsigned int sh_type)
3780{
3781 switch (sh_type)
3782 {
3783 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3784 default:
3785 break;
3786 }
3787 return NULL;
3788}
3789
a06ea964
NC		 3790static const char *
3791get_aarch64_section_type_name (unsigned int sh_type)
3792{
3793 switch (sh_type)
3794 {
3795 case SHT_AARCH64_ATTRIBUTES:
3796 return "AARCH64_ATTRIBUTES";
3797 default:
3798 break;
3799 }
3800 return NULL;
3801}
3802
40a18ebd
NC		 3803static const char *
3804get_arm_section_type_name (unsigned int sh_type)
3805{
3806 switch (sh_type)
3807 {
7f6fed87
NC		 3808 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3809 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3810 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3811 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3812 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3813 default:
3814 break;
3815 }
3816 return NULL;
3817}
3818
40b36596
JM		 3819static const char *
3820get_tic6x_section_type_name (unsigned int sh_type)
3821{
3822 switch (sh_type)
3823 {
3824 case SHT_C6000_UNWIND:
3825 return "C6000_UNWIND";
3826 case SHT_C6000_PREEMPTMAP:
3827 return "C6000_PREEMPTMAP";
3828 case SHT_C6000_ATTRIBUTES:
3829 return "C6000_ATTRIBUTES";
3830 case SHT_TI_ICODE:
3831 return "TI_ICODE";
3832 case SHT_TI_XREF:
3833 return "TI_XREF";
3834 case SHT_TI_HANDLER:
3835 return "TI_HANDLER";
3836 case SHT_TI_INITINFO:
3837 return "TI_INITINFO";
3838 case SHT_TI_PHATTRS:
3839 return "TI_PHATTRS";
3840 default:
3841 break;
3842 }
3843 return NULL;
3844}
3845
13761a11
NC		 3846static const char *
3847get_msp430x_section_type_name (unsigned int sh_type)
3848{
3849 switch (sh_type)
3850 {
3851 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3852 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3853 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3854 default: return NULL;
3855 }
3856}
3857
685080f2
NC		 3858static const char *
3859get_v850_section_type_name (unsigned int sh_type)
3860{
3861 switch (sh_type)
3862 {
3863 case SHT_V850_SCOMMON: return "V850 Small Common";
3864 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3865 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3866 case SHT_RENESAS_IOP: return "RENESAS IOP";
3867 case SHT_RENESAS_INFO: return "RENESAS INFO";
3868 default: return NULL;
3869 }
3870}
3871
252b5132 3872static const char *
d3ba0551 3873get_section_type_name (unsigned int sh_type)
252b5132 3874{
b34976b6 3875 static char buff[32];
252b5132
RH		 3876
3877 switch (sh_type)
3878 {
3879 case SHT_NULL: return "NULL";
3880 case SHT_PROGBITS: return "PROGBITS";
3881 case SHT_SYMTAB: return "SYMTAB";
3882 case SHT_STRTAB: return "STRTAB";
3883 case SHT_RELA: return "RELA";
3884 case SHT_HASH: return "HASH";
3885 case SHT_DYNAMIC: return "DYNAMIC";
3886 case SHT_NOTE: return "NOTE";
3887 case SHT_NOBITS: return "NOBITS";
3888 case SHT_REL: return "REL";
3889 case SHT_SHLIB: return "SHLIB";
3890 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3891 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3892 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3893 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3894 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3895 case SHT_GROUP: return "GROUP";
3896 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3897 case SHT_GNU_verdef: return "VERDEF";
3898 case SHT_GNU_verneed: return "VERNEED";
3899 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3900 case 0x6ffffff0: return "VERSYM";
3901 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3902 case 0x7ffffffd: return "AUXILIARY";
3903 case 0x7fffffff: return "FILTER";
047b2264 3904 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3905
3906 default:
3907 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3908 {
2cf0635d 3909 const char * result;
252b5132
RH		 3910
3911 switch (elf_header.e_machine)
3912 {
3913 case EM_MIPS:
4fe85591 3914 case EM_MIPS_RS3_LE:
252b5132
RH		 3915 result = get_mips_section_type_name (sh_type);
3916 break;
103f02d3
UD		 3917 case EM_PARISC:
3918 result = get_parisc_section_type_name (sh_type);
3919 break;
4d6ed7c8
NC		 3920 case EM_IA_64:
3921 result = get_ia64_section_type_name (sh_type);
3922 break;
d2b2c203 3923 case EM_X86_64:
8a9036a4 3924 case EM_L1OM:
7a9068fe 3925 case EM_K1OM:
d2b2c203
DJ		 3926 result = get_x86_64_section_type_name (sh_type);
3927 break;
a06ea964
NC		 3928 case EM_AARCH64:
3929 result = get_aarch64_section_type_name (sh_type);
3930 break;
40a18ebd
NC		 3931 case EM_ARM:
3932 result = get_arm_section_type_name (sh_type);
3933 break;
40b36596
JM		 3934 case EM_TI_C6000:
3935 result = get_tic6x_section_type_name (sh_type);
3936 break;
13761a11
NC		 3937 case EM_MSP430:
3938 result = get_msp430x_section_type_name (sh_type);
3939 break;
685080f2
NC		 3940 case EM_V800:
3941 case EM_V850:
3942 case EM_CYGNUS_V850:
3943 result = get_v850_section_type_name (sh_type);
3944 break;
252b5132
RH		 3945 default:
3946 result = NULL;
3947 break;
3948 }
3949
3950 if (result != NULL)
3951 return result;
3952
c91d0dfb 3953 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3954 }
3955 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3956 {
2cf0635d 3957 const char * result;
148b93f2
NC		 3958
3959 switch (elf_header.e_machine)
3960 {
3961 case EM_IA_64:
3962 result = get_ia64_section_type_name (sh_type);
3963 break;
3964 default:
3965 result = NULL;
3966 break;
3967 }
3968
3969 if (result != NULL)
3970 return result;
3971
3972 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3973 }
252b5132 3974 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3975 {
3976 switch (elf_header.e_machine)
3977 {
3978 case EM_V800:
3979 case EM_V850:
3980 case EM_CYGNUS_V850:
3981 return get_v850_section_type_name (sh_type);
3982 default:
3983 break;
3984 }
3985
3986 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3987 }
252b5132 3988 else
a7dbfd1c
NC		 3989 /* This message is probably going to be displayed in a 15
3990 character wide field, so put the hex value first. */
3991 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3992
252b5132
RH		 3993 return buff;
3994 }
3995}
3996
2979dc34 3997#define OPTION_DEBUG_DUMP 512
2c610e4b 3998#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3999#define OPTION_DWARF_DEPTH 514
4000#define OPTION_DWARF_START 515
4723351a 4001#define OPTION_DWARF_CHECK 516
2979dc34 4002
85b1c36d 4003static struct option options[] =
252b5132 4004{
b34976b6 4005 {"all", no_argument, 0, 'a'},
252b5132
RH		 4006 {"file-header", no_argument, 0, 'h'},
4007 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4008 {"headers", no_argument, 0, 'e'},
4009 {"histogram", no_argument, 0, 'I'},
4010 {"segments", no_argument, 0, 'l'},
4011 {"sections", no_argument, 0, 'S'},
252b5132 4012 {"section-headers", no_argument, 0, 'S'},
f5842774 4013 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4014 {"section-details", no_argument, 0, 't'},
595cf52e 4015 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4016 {"symbols", no_argument, 0, 's'},
4017 {"syms", no_argument, 0, 's'},
2c610e4b 4018 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4019 {"relocs", no_argument, 0, 'r'},
4020 {"notes", no_argument, 0, 'n'},
4021 {"dynamic", no_argument, 0, 'd'},
a952a375 4022 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4023 {"version-info", no_argument, 0, 'V'},
4024 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4025 {"unwind", no_argument, 0, 'u'},
4145f1d5 4026 {"archive-index", no_argument, 0, 'c'},
b34976b6 4027 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4028 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4029 {"string-dump", required_argument, 0, 'p'},
0e602686 4030 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4031#ifdef SUPPORT_DISASSEMBLY
4032 {"instruction-dump", required_argument, 0, 'i'},
4033#endif
cf13d699 4034 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4035
fd2f0033
TT		 4036 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4037 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4038 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4039
b34976b6
AM		 4040 {"version", no_argument, 0, 'v'},
4041 {"wide", no_argument, 0, 'W'},
4042 {"help", no_argument, 0, 'H'},
4043 {0, no_argument, 0, 0}
252b5132
RH		 4044};
4045
4046static void
2cf0635d 4047usage (FILE * stream)
252b5132 4048{
92f01d61
JM		 4049 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4050 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4051 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4052 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4053 -h --file-header Display the ELF file header\n\
4054 -l --program-headers Display the program headers\n\
4055 --segments An alias for --program-headers\n\
4056 -S --section-headers Display the sections' header\n\
4057 --sections An alias for --section-headers\n\
f5842774 4058 -g --section-groups Display the section groups\n\
5477e8a0 4059 -t --section-details Display the section details\n\
8b53311e
NC		 4060 -e --headers Equivalent to: -h -l -S\n\
4061 -s --syms Display the symbol table\n\
3f08eb35 4062 --symbols An alias for --syms\n\
2c610e4b 4063 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4064 -n --notes Display the core notes (if present)\n\
4065 -r --relocs Display the relocations (if present)\n\
4066 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4067 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4068 -V --version-info Display the version sections (if present)\n\
1b31d05e 4069 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4070 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4071 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4072 -x --hex-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as bytes\n\
4074 -p --string-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4076 -R --relocated-dump=<number|name>\n\
4077 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4078 -z --decompress Decompress section before dumping it\n\
f9f0e732 4079 -w[lLiaprmfFsoRt] or\n\
1ed06042 4080 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4081 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4082 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4083 =addr,=cu_index]\n\
8b53311e 4084 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4085 fprintf (stream, _("\
4086 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4087 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4088 or deeper\n"));
252b5132 4089#ifdef SUPPORT_DISASSEMBLY
92f01d61 4090 fprintf (stream, _("\
09c11c86
NC		 4091 -i --instruction-dump=<number|name>\n\
4092 Disassemble the contents of section <number|name>\n"));
252b5132 4093#endif
92f01d61 4094 fprintf (stream, _("\
8b53311e
NC		 4095 -I --histogram Display histogram of bucket list lengths\n\
4096 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4097 @<file> Read options from <file>\n\
8b53311e
NC		 4098 -H --help Display this information\n\
4099 -v --version Display the version number of readelf\n"));
1118d252 4100
92f01d61
JM		 4101 if (REPORT_BUGS_TO[0] && stream == stdout)
4102 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4103
92f01d61 4104 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4105}
4106
18bd398b
NC		 4107/* Record the fact that the user wants the contents of section number
4108 SECTION to be displayed using the method(s) encoded as flags bits
4109 in TYPE. Note, TYPE can be zero if we are creating the array for
4110 the first time. */
4111
252b5132 4112static void
09c11c86 4113request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4114{
4115 if (section >= num_dump_sects)
4116 {
2cf0635d 4117 dump_type * new_dump_sects;
252b5132 4118
3f5e193b
NC		 4119 new_dump_sects = (dump_type *) calloc (section + 1,
4120 sizeof (* dump_sects));
252b5132
RH		 4121
4122 if (new_dump_sects == NULL)
591a748a 4123 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4124 else
4125 {
4126 /* Copy current flag settings. */
09c11c86 4127 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4128
4129 free (dump_sects);
4130
4131 dump_sects = new_dump_sects;
4132 num_dump_sects = section + 1;
4133 }
4134 }
4135
4136 if (dump_sects)
b34976b6 4137 dump_sects[section] |= type;
252b5132
RH		 4138
4139 return;
4140}
4141
aef1f6d0
DJ		 4142/* Request a dump by section name. */
4143
4144static void
2cf0635d 4145request_dump_byname (const char * section, dump_type type)
aef1f6d0 4146{
2cf0635d 4147 struct dump_list_entry * new_request;
aef1f6d0 4148
3f5e193b
NC		 4149 new_request = (struct dump_list_entry *)
4150 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4151 if (!new_request)
591a748a 4152 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4153
4154 new_request->name = strdup (section);
4155 if (!new_request->name)
591a748a 4156 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4157
4158 new_request->type = type;
4159
4160 new_request->next = dump_sects_byname;
4161 dump_sects_byname = new_request;
4162}
4163
cf13d699
NC		 4164static inline void
4165request_dump (dump_type type)
4166{
4167 int section;
4168 char * cp;
4169
4170 do_dump++;
4171 section = strtoul (optarg, & cp, 0);
4172
4173 if (! *cp && section >= 0)
4174 request_dump_bynumber (section, type);
4175 else
4176 request_dump_byname (optarg, type);
4177}
4178
4179
252b5132 4180static void
2cf0635d 4181parse_args (int argc, char ** argv)
252b5132
RH		 4182{
4183 int c;
4184
4185 if (argc < 2)
92f01d61 4186 usage (stderr);
252b5132
RH		 4187
4188 while ((c = getopt_long
0e602686 4189 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4190 {
252b5132
RH		 4191 switch (c)
4192 {
4193 case 0:
4194 /* Long options. */
4195 break;
4196 case 'H':
92f01d61 4197 usage (stdout);
252b5132
RH		 4198 break;
4199
4200 case 'a':
b34976b6
AM		 4201 do_syms++;
4202 do_reloc++;
4203 do_unwind++;
4204 do_dynamic++;
4205 do_header++;
4206 do_sections++;
f5842774 4207 do_section_groups++;
b34976b6
AM		 4208 do_segments++;
4209 do_version++;
4210 do_histogram++;
4211 do_arch++;
4212 do_notes++;
252b5132 4213 break;
f5842774
L		 4214 case 'g':
4215 do_section_groups++;
4216 break;
5477e8a0 4217 case 't':
595cf52e 4218 case 'N':
5477e8a0
L		 4219 do_sections++;
4220 do_section_details++;
595cf52e 4221 break;
252b5132 4222 case 'e':
b34976b6
AM		 4223 do_header++;
4224 do_sections++;
4225 do_segments++;
252b5132 4226 break;
a952a375 4227 case 'A':
b34976b6 4228 do_arch++;
a952a375 4229 break;
252b5132 4230 case 'D':
b34976b6 4231 do_using_dynamic++;
252b5132
RH		 4232 break;
4233 case 'r':
b34976b6 4234 do_reloc++;
252b5132 4235 break;
4d6ed7c8 4236 case 'u':
b34976b6 4237 do_unwind++;
4d6ed7c8 4238 break;
252b5132 4239 case 'h':
b34976b6 4240 do_header++;
252b5132
RH		 4241 break;
4242 case 'l':
b34976b6 4243 do_segments++;
252b5132
RH		 4244 break;
4245 case 's':
b34976b6 4246 do_syms++;
252b5132
RH		 4247 break;
4248 case 'S':
b34976b6 4249 do_sections++;
252b5132
RH		 4250 break;
4251 case 'd':
b34976b6 4252 do_dynamic++;
252b5132 4253 break;
a952a375 4254 case 'I':
b34976b6 4255 do_histogram++;
a952a375 4256 break;
779fe533 4257 case 'n':
b34976b6 4258 do_notes++;
779fe533 4259 break;
4145f1d5
NC		 4260 case 'c':
4261 do_archive_index++;
4262 break;
252b5132 4263 case 'x':
cf13d699 4264 request_dump (HEX_DUMP);
aef1f6d0 4265 break;
09c11c86 4266 case 'p':
cf13d699
NC		 4267 request_dump (STRING_DUMP);
4268 break;
4269 case 'R':
4270 request_dump (RELOC_DUMP);
09c11c86 4271 break;
0e602686
NC		 4272 case 'z':
4273 decompress_dumps++;
4274 break;
252b5132 4275 case 'w':
b34976b6 4276 do_dump++;
252b5132 4277 if (optarg == 0)
613ff48b
CC		 4278 {
4279 do_debugging = 1;
4280 dwarf_select_sections_all ();
4281 }
252b5132
RH		 4282 else
4283 {
4284 do_debugging = 0;
4cb93e3b 4285 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4286 }
4287 break;
2979dc34 4288 case OPTION_DEBUG_DUMP:
b34976b6 4289 do_dump++;
2979dc34
JJ		 4290 if (optarg == 0)
4291 do_debugging = 1;
4292 else
4293 {
2979dc34 4294 do_debugging = 0;
4cb93e3b 4295 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4296 }
4297 break;
fd2f0033
TT		 4298 case OPTION_DWARF_DEPTH:
4299 {
4300 char *cp;
4301
4302 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4303 }
4304 break;
4305 case OPTION_DWARF_START:
4306 {
4307 char *cp;
4308
4309 dwarf_start_die = strtoul (optarg, & cp, 0);
4310 }
4311 break;
4723351a
CC		 4312 case OPTION_DWARF_CHECK:
4313 dwarf_check = 1;
4314 break;
2c610e4b
L		 4315 case OPTION_DYN_SYMS:
4316 do_dyn_syms++;
4317 break;
252b5132
RH		 4318#ifdef SUPPORT_DISASSEMBLY
4319 case 'i':
cf13d699
NC		 4320 request_dump (DISASS_DUMP);
4321 break;
252b5132
RH		 4322#endif
4323 case 'v':
4324 print_version (program_name);
4325 break;
4326 case 'V':
b34976b6 4327 do_version++;
252b5132 4328 break;
d974e256 4329 case 'W':
b34976b6 4330 do_wide++;
d974e256 4331 break;
252b5132 4332 default:
252b5132
RH		 4333 /* xgettext:c-format */
4334 error (_("Invalid option '-%c'\n"), c);
4335 /* Drop through. */
4336 case '?':
92f01d61 4337 usage (stderr);
252b5132
RH		 4338 }
4339 }
4340
4d6ed7c8 4341 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4342 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4343 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4344 && !do_section_groups && !do_archive_index
4345 && !do_dyn_syms)
92f01d61 4346 usage (stderr);
252b5132
RH		 4347}
4348
4349static const char *
d3ba0551 4350get_elf_class (unsigned int elf_class)
252b5132 4351{
b34976b6 4352 static char buff[32];
103f02d3 4353
252b5132
RH		 4354 switch (elf_class)
4355 {
4356 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4357 case ELFCLASS32: return "ELF32";
4358 case ELFCLASS64: return "ELF64";
ab5e7794 4359 default:
e9e44622 4360 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4361 return buff;
252b5132
RH		 4362 }
4363}
4364
4365static const char *
d3ba0551 4366get_data_encoding (unsigned int encoding)
252b5132 4367{
b34976b6 4368 static char buff[32];
103f02d3 4369
252b5132
RH		 4370 switch (encoding)
4371 {
4372 case ELFDATANONE: return _("none");
33c63f9d
CM		 4373 case ELFDATA2LSB: return _("2's complement, little endian");
4374 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4375 default:
e9e44622 4376 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4377 return buff;
252b5132
RH		 4378 }
4379}
4380
252b5132 4381/* Decode the data held in 'elf_header'. */
ee42cf8c 4382
252b5132 4383static int
d3ba0551 4384process_file_header (void)
252b5132 4385{
b34976b6
AM		 4386 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4387 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4388 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4389 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4390 {
4391 error
4392 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4393 return 0;
4394 }
4395
2dc4cec1
L		 4396 init_dwarf_regnames (elf_header.e_machine);
4397
252b5132
RH		 4398 if (do_header)
4399 {
4400 int i;
4401
4402 printf (_("ELF Header:\n"));
4403 printf (_(" Magic: "));
b34976b6
AM		 4404 for (i = 0; i < EI_NIDENT; i++)
4405 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4406 printf ("\n");
4407 printf (_(" Class: %s\n"),
b34976b6 4408 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4409 printf (_(" Data: %s\n"),
b34976b6 4410 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4411 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4412 elf_header.e_ident[EI_VERSION],
4413 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4414 ? "(current)"
b34976b6 4415 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4416 ? _("<unknown: %lx>")
789be9f7 4417 : "")));
252b5132 4418 printf (_(" OS/ABI: %s\n"),
b34976b6 4419 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4420 printf (_(" ABI Version: %d\n"),
b34976b6 4421 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4422 printf (_(" Type: %s\n"),
4423 get_file_type (elf_header.e_type));
4424 printf (_(" Machine: %s\n"),
4425 get_machine_name (elf_header.e_machine));
4426 printf (_(" Version: 0x%lx\n"),
4427 (unsigned long) elf_header.e_version);
76da6bbe 4428
f7a99963
NC		 4429 printf (_(" Entry point address: "));
4430 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4431 printf (_("\n Start of program headers: "));
4432 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4433 printf (_(" (bytes into file)\n Start of section headers: "));
4434 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4435 printf (_(" (bytes into file)\n"));
76da6bbe 4436
252b5132
RH		 4437 printf (_(" Flags: 0x%lx%s\n"),
4438 (unsigned long) elf_header.e_flags,
4439 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4440 printf (_(" Size of this header: %ld (bytes)\n"),
4441 (long) elf_header.e_ehsize);
4442 printf (_(" Size of program headers: %ld (bytes)\n"),
4443 (long) elf_header.e_phentsize);
2046a35d 4444 printf (_(" Number of program headers: %ld"),
252b5132 4445 (long) elf_header.e_phnum);
2046a35d
AM		 4446 if (section_headers != NULL
4447 && elf_header.e_phnum == PN_XNUM
4448 && section_headers[0].sh_info != 0)
cc5914eb 4449 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4450 putc ('\n', stdout);
252b5132
RH		 4451 printf (_(" Size of section headers: %ld (bytes)\n"),
4452 (long) elf_header.e_shentsize);
560f3c1c 4453 printf (_(" Number of section headers: %ld"),
252b5132 4454 (long) elf_header.e_shnum);
4fbb74a6 4455 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4456 printf (" (%ld)", (long) section_headers[0].sh_size);
4457 putc ('\n', stdout);
4458 printf (_(" Section header string table index: %ld"),
252b5132 4459 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4460 if (section_headers != NULL
4461 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4462 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4463 else if (elf_header.e_shstrndx != SHN_UNDEF
4464 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4465 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4466 putc ('\n', stdout);
4467 }
4468
4469 if (section_headers != NULL)
4470 {
2046a35d
AM		 4471 if (elf_header.e_phnum == PN_XNUM
4472 && section_headers[0].sh_info != 0)
4473 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4474 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4475 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4476 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4477 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4478 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4479 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4480 free (section_headers);
4481 section_headers = NULL;
252b5132 4482 }
103f02d3 4483
9ea033b2
NC		 4484 return 1;
4485}
4486
e0a31db1 4487static bfd_boolean
91d6fa6a 4488get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4489{
2cf0635d
NC		 4490 Elf32_External_Phdr * phdrs;
4491 Elf32_External_Phdr * external;
4492 Elf_Internal_Phdr * internal;
b34976b6 4493 unsigned int i;
e0a31db1
NC		 4494 unsigned int size = elf_header.e_phentsize;
4495 unsigned int num = elf_header.e_phnum;
4496
4497 /* PR binutils/17531: Cope with unexpected section header sizes. */
4498 if (size == 0 || num == 0)
4499 return FALSE;
4500 if (size < sizeof * phdrs)
4501 {
4502 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4503 return FALSE;
4504 }
4505 if (size > sizeof * phdrs)
4506 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4507
3f5e193b 4508 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4509 size, num, _("program headers"));
4510 if (phdrs == NULL)
4511 return FALSE;
9ea033b2 4512
91d6fa6a 4513 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4514 i < elf_header.e_phnum;
b34976b6 4515 i++, internal++, external++)
252b5132 4516 {
9ea033b2
NC		 4517 internal->p_type = BYTE_GET (external->p_type);
4518 internal->p_offset = BYTE_GET (external->p_offset);
4519 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4520 internal->p_paddr = BYTE_GET (external->p_paddr);
4521 internal->p_filesz = BYTE_GET (external->p_filesz);
4522 internal->p_memsz = BYTE_GET (external->p_memsz);
4523 internal->p_flags = BYTE_GET (external->p_flags);
4524 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4525 }
4526
9ea033b2 4527 free (phdrs);
e0a31db1 4528 return TRUE;
252b5132
RH		 4529}
4530
e0a31db1 4531static bfd_boolean
91d6fa6a 4532get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4533{
2cf0635d
NC		 4534 Elf64_External_Phdr * phdrs;
4535 Elf64_External_Phdr * external;
4536 Elf_Internal_Phdr * internal;
b34976b6 4537 unsigned int i;
e0a31db1
NC		 4538 unsigned int size = elf_header.e_phentsize;
4539 unsigned int num = elf_header.e_phnum;
4540
4541 /* PR binutils/17531: Cope with unexpected section header sizes. */
4542 if (size == 0 || num == 0)
4543 return FALSE;
4544 if (size < sizeof * phdrs)
4545 {
4546 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4547 return FALSE;
4548 }
4549 if (size > sizeof * phdrs)
4550 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4551
3f5e193b 4552 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4553 size, num, _("program headers"));
a6e9f9df 4554 if (!phdrs)
e0a31db1 4555 return FALSE;
9ea033b2 4556
91d6fa6a 4557 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4558 i < elf_header.e_phnum;
b34976b6 4559 i++, internal++, external++)
9ea033b2
NC		 4560 {
4561 internal->p_type = BYTE_GET (external->p_type);
4562 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4563 internal->p_offset = BYTE_GET (external->p_offset);
4564 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4565 internal->p_paddr = BYTE_GET (external->p_paddr);
4566 internal->p_filesz = BYTE_GET (external->p_filesz);
4567 internal->p_memsz = BYTE_GET (external->p_memsz);
4568 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4569 }
4570
4571 free (phdrs);
e0a31db1 4572 return TRUE;
9ea033b2 4573}
252b5132 4574
d93f0186
NC		 4575/* Returns 1 if the program headers were read into `program_headers'. */
4576
4577static int
2cf0635d 4578get_program_headers (FILE * file)
d93f0186 4579{
2cf0635d 4580 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4581
4582 /* Check cache of prior read. */
4583 if (program_headers != NULL)
4584 return 1;
4585
3f5e193b
NC		 4586 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4587 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4588
4589 if (phdrs == NULL)
4590 {
8b73c356
NC		 4591 error (_("Out of memory reading %u program headers\n"),
4592 elf_header.e_phnum);
d93f0186
NC		 4593 return 0;
4594 }
4595
4596 if (is_32bit_elf
4597 ? get_32bit_program_headers (file, phdrs)
4598 : get_64bit_program_headers (file, phdrs))
4599 {
4600 program_headers = phdrs;
4601 return 1;
4602 }
4603
4604 free (phdrs);
4605 return 0;
4606}
4607
2f62977e
NC		 4608/* Returns 1 if the program headers were loaded. */
4609
252b5132 4610static int
2cf0635d 4611process_program_headers (FILE * file)
252b5132 4612{
2cf0635d 4613 Elf_Internal_Phdr * segment;
b34976b6 4614 unsigned int i;
252b5132
RH		 4615
4616 if (elf_header.e_phnum == 0)
4617 {
82f2dbf7
NC		 4618 /* PR binutils/12467. */
4619 if (elf_header.e_phoff != 0)
4620 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4621 " header offset, but no program headers\n"));
82f2dbf7 4622 else if (do_segments)
252b5132 4623 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4624 return 0;
252b5132
RH		 4625 }
4626
4627 if (do_segments && !do_header)
4628 {
f7a99963
NC		 4629 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4630 printf (_("Entry point "));
4631 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4632 printf (_("\nThere are %d program headers, starting at offset "),
4633 elf_header.e_phnum);
4634 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4635 printf ("\n");
252b5132
RH		 4636 }
4637
d93f0186 4638 if (! get_program_headers (file))
252b5132 4639 return 0;
103f02d3 4640
252b5132
RH		 4641 if (do_segments)
4642 {
3a1a2036
NC		 4643 if (elf_header.e_phnum > 1)
4644 printf (_("\nProgram Headers:\n"));
4645 else
4646 printf (_("\nProgram Headers:\n"));
76da6bbe 4647
f7a99963
NC		 4648 if (is_32bit_elf)
4649 printf
4650 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4651 else if (do_wide)
4652 printf
4653 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4654 else
4655 {
4656 printf
4657 (_(" Type Offset VirtAddr PhysAddr\n"));
4658 printf
4659 (_(" FileSiz MemSiz Flags Align\n"));
4660 }
252b5132
RH		 4661 }
4662
252b5132 4663 dynamic_addr = 0;
1b228002 4664 dynamic_size = 0;
252b5132
RH		 4665
4666 for (i = 0, segment = program_headers;
4667 i < elf_header.e_phnum;
b34976b6 4668 i++, segment++)
252b5132
RH		 4669 {
4670 if (do_segments)
4671 {
103f02d3 4672 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4673
4674 if (is_32bit_elf)
4675 {
4676 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4677 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4678 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4679 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4680 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4681 printf ("%c%c%c ",
4682 (segment->p_flags & PF_R ? 'R' : ' '),
4683 (segment->p_flags & PF_W ? 'W' : ' '),
4684 (segment->p_flags & PF_X ? 'E' : ' '));
4685 printf ("%#lx", (unsigned long) segment->p_align);
4686 }
d974e256
JJ		 4687 else if (do_wide)
4688 {
4689 if ((unsigned long) segment->p_offset == segment->p_offset)
4690 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4691 else
4692 {
4693 print_vma (segment->p_offset, FULL_HEX);
4694 putchar (' ');
4695 }
4696
4697 print_vma (segment->p_vaddr, FULL_HEX);
4698 putchar (' ');
4699 print_vma (segment->p_paddr, FULL_HEX);
4700 putchar (' ');
4701
4702 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4703 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4704 else
4705 {
4706 print_vma (segment->p_filesz, FULL_HEX);
4707 putchar (' ');
4708 }
4709
4710 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4711 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4712 else
4713 {
f48e6c45 4714 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4715 }
4716
4717 printf (" %c%c%c ",
4718 (segment->p_flags & PF_R ? 'R' : ' '),
4719 (segment->p_flags & PF_W ? 'W' : ' '),
4720 (segment->p_flags & PF_X ? 'E' : ' '));
4721
4722 if ((unsigned long) segment->p_align == segment->p_align)
4723 printf ("%#lx", (unsigned long) segment->p_align);
4724 else
4725 {
4726 print_vma (segment->p_align, PREFIX_HEX);
4727 }
4728 }
f7a99963
NC		 4729 else
4730 {
4731 print_vma (segment->p_offset, FULL_HEX);
4732 putchar (' ');
4733 print_vma (segment->p_vaddr, FULL_HEX);
4734 putchar (' ');
4735 print_vma (segment->p_paddr, FULL_HEX);
4736 printf ("\n ");
4737 print_vma (segment->p_filesz, FULL_HEX);
4738 putchar (' ');
4739 print_vma (segment->p_memsz, FULL_HEX);
4740 printf (" %c%c%c ",
4741 (segment->p_flags & PF_R ? 'R' : ' '),
4742 (segment->p_flags & PF_W ? 'W' : ' '),
4743 (segment->p_flags & PF_X ? 'E' : ' '));
4744 print_vma (segment->p_align, HEX);
4745 }
252b5132
RH		 4746 }
4747
f54498b4
NC		 4748 if (do_segments)
4749 putc ('\n', stdout);
4750
252b5132
RH		 4751 switch (segment->p_type)
4752 {
252b5132
RH		 4753 case PT_DYNAMIC:
4754 if (dynamic_addr)
4755 error (_("more than one dynamic segment\n"));
4756
20737c13
AM		 4757 /* By default, assume that the .dynamic section is the first
4758 section in the DYNAMIC segment. */
4759 dynamic_addr = segment->p_offset;
4760 dynamic_size = segment->p_filesz;
f54498b4
NC		 4761 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4762 if (dynamic_addr + dynamic_size >= current_file_size)
4763 {
4764 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4765 dynamic_addr = dynamic_size = 0;
4766 }
20737c13 4767
b2d38a17
NC		 4768 /* Try to locate the .dynamic section. If there is
4769 a section header table, we can easily locate it. */
4770 if (section_headers != NULL)
4771 {
2cf0635d 4772 Elf_Internal_Shdr * sec;
b2d38a17 4773
89fac5e3
RS		 4774 sec = find_section (".dynamic");
4775 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4776 {
28f997cf
TG		 4777 /* A corresponding .dynamic section is expected, but on
4778 IA-64/OpenVMS it is OK for it to be missing. */
4779 if (!is_ia64_vms ())
4780 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4781 break;
4782 }
4783
42bb2e33 4784 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4785 {
4786 dynamic_size = 0;
4787 break;
4788 }
42bb2e33 4789
b2d38a17
NC		 4790 dynamic_addr = sec->sh_offset;
4791 dynamic_size = sec->sh_size;
4792
4793 if (dynamic_addr < segment->p_offset
4794 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4795 warn (_("the .dynamic section is not contained"
4796 " within the dynamic segment\n"));
b2d38a17 4797 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4798 warn (_("the .dynamic section is not the first section"
4799 " in the dynamic segment.\n"));
b2d38a17 4800 }
252b5132
RH		 4801 break;
4802
4803 case PT_INTERP:
fb52b2f4
NC		 4804 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4805 SEEK_SET))
252b5132
RH		 4806 error (_("Unable to find program interpreter name\n"));
4807 else
4808 {
f8eae8b2 4809 char fmt [32];
9495b2e6 4810 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4811
4812 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4813 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4814
252b5132 4815 program_interpreter[0] = 0;
7bd7b3ef
AM		 4816 if (fscanf (file, fmt, program_interpreter) <= 0)
4817 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4818
4819 if (do_segments)
f54498b4 4820 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4821 program_interpreter);
4822 }
4823 break;
4824 }
252b5132
RH		 4825 }
4826
c256ffe7 4827 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4828 {
4829 printf (_("\n Section to Segment mapping:\n"));
4830 printf (_(" Segment Sections...\n"));
4831
252b5132
RH		 4832 for (i = 0; i < elf_header.e_phnum; i++)
4833 {
9ad5cbcf 4834 unsigned int j;
2cf0635d 4835 Elf_Internal_Shdr * section;
252b5132
RH		 4836
4837 segment = program_headers + i;
b391a3e3 4838 section = section_headers + 1;
252b5132
RH		 4839
4840 printf (" %2.2d ", i);
4841
b34976b6 4842 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4843 {
f4638467
AM		 4844 if (!ELF_TBSS_SPECIAL (section, segment)
4845 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4846 printf ("%s ", printable_section_name (section));
252b5132
RH		 4847 }
4848
4849 putc ('\n',stdout);
4850 }
4851 }
4852
252b5132
RH		 4853 return 1;
4854}
4855
4856
d93f0186
NC		 4857/* Find the file offset corresponding to VMA by using the program headers. */
4858
4859static long
2cf0635d 4860offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4861{
2cf0635d 4862 Elf_Internal_Phdr * seg;
d93f0186
NC		 4863
4864 if (! get_program_headers (file))
4865 {
4866 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4867 return (long) vma;
4868 }
4869
4870 for (seg = program_headers;
4871 seg < program_headers + elf_header.e_phnum;
4872 ++seg)
4873 {
4874 if (seg->p_type != PT_LOAD)
4875 continue;
4876
4877 if (vma >= (seg->p_vaddr & -seg->p_align)
4878 && vma + size <= seg->p_vaddr + seg->p_filesz)
4879 return vma - seg->p_vaddr + seg->p_offset;
4880 }
4881
4882 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4883 (unsigned long) vma);
d93f0186
NC		 4884 return (long) vma;
4885}
4886
4887
049b0c3a
NC		 4888/* Allocate memory and load the sections headers into the global pointer
4889 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4890 generate any error messages if the load fails. */
4891
4892static bfd_boolean
4893get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4894{
2cf0635d
NC		 4895 Elf32_External_Shdr * shdrs;
4896 Elf_Internal_Shdr * internal;
b34976b6 4897 unsigned int i;
049b0c3a
NC		 4898 unsigned int size = elf_header.e_shentsize;
4899 unsigned int num = probe ? 1 : elf_header.e_shnum;
4900
4901 /* PR binutils/17531: Cope with unexpected section header sizes. */
4902 if (size == 0 || num == 0)
4903 return FALSE;
4904 if (size < sizeof * shdrs)
4905 {
4906 if (! probe)
4907 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4908 return FALSE;
4909 }
4910 if (!probe && size > sizeof * shdrs)
4911 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4912
3f5e193b 4913 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4914 size, num,
4915 probe ? NULL : _("section headers"));
4916 if (shdrs == NULL)
4917 return FALSE;
252b5132 4918
049b0c3a
NC		 4919 if (section_headers != NULL)
4920 free (section_headers);
3f5e193b
NC		 4921 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4922 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4923 if (section_headers == NULL)
4924 {
049b0c3a 4925 if (!probe)
8b73c356 4926 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4927 return FALSE;
252b5132
RH		 4928 }
4929
4930 for (i = 0, internal = section_headers;
560f3c1c 4931 i < num;
b34976b6 4932 i++, internal++)
252b5132
RH		 4933 {
4934 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4935 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4936 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4937 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4938 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4939 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4940 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4941 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4942 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4943 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4944 }
4945
4946 free (shdrs);
049b0c3a 4947 return TRUE;
252b5132
RH		 4948}
4949
049b0c3a
NC		 4950static bfd_boolean
4951get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4952{
2cf0635d
NC		 4953 Elf64_External_Shdr * shdrs;
4954 Elf_Internal_Shdr * internal;
b34976b6 4955 unsigned int i;
049b0c3a
NC		 4956 unsigned int size = elf_header.e_shentsize;
4957 unsigned int num = probe ? 1 : elf_header.e_shnum;
4958
4959 /* PR binutils/17531: Cope with unexpected section header sizes. */
4960 if (size == 0 || num == 0)
4961 return FALSE;
4962 if (size < sizeof * shdrs)
4963 {
4964 if (! probe)
4965 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4966 return FALSE;
4967 }
4968 if (! probe && size > sizeof * shdrs)
4969 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4970
3f5e193b 4971 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4972 size, num,
4973 probe ? NULL : _("section headers"));
4974 if (shdrs == NULL)
4975 return FALSE;
9ea033b2 4976
049b0c3a
NC		 4977 if (section_headers != NULL)
4978 free (section_headers);
3f5e193b
NC		 4979 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4980 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4981 if (section_headers == NULL)
4982 {
049b0c3a 4983 if (! probe)
8b73c356 4984 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4985 return FALSE;
9ea033b2
NC		 4986 }
4987
4988 for (i = 0, internal = section_headers;
560f3c1c 4989 i < num;
b34976b6 4990 i++, internal++)
9ea033b2
NC		 4991 {
4992 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4993 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4994 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4995 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4996 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4997 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4998 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4999 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5000 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5001 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5002 }
5003
5004 free (shdrs);
049b0c3a 5005 return TRUE;
9ea033b2
NC		 5006}
5007
252b5132 5008static Elf_Internal_Sym *
ba5cdace
NC		 5009get_32bit_elf_symbols (FILE * file,
5010 Elf_Internal_Shdr * section,
5011 unsigned long * num_syms_return)
252b5132 5012{
ba5cdace 5013 unsigned long number = 0;
dd24e3da 5014 Elf32_External_Sym * esyms = NULL;
ba5cdace 5015 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5016 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5017 Elf_Internal_Sym * psym;
b34976b6 5018 unsigned int j;
252b5132 5019
c9c1d674
EG		 5020 if (section->sh_size == 0)
5021 {
5022 if (num_syms_return != NULL)
5023 * num_syms_return = 0;
5024 return NULL;
5025 }
5026
dd24e3da 5027 /* Run some sanity checks first. */
c9c1d674 5028 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5029 {
c9c1d674
EG		 5030 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5031 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5032 goto exit_point;
dd24e3da
NC		 5033 }
5034
f54498b4
NC		 5035 if (section->sh_size > current_file_size)
5036 {
5037 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5038 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5039 goto exit_point;
5040 }
5041
dd24e3da
NC		 5042 number = section->sh_size / section->sh_entsize;
5043
5044 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5045 {
c9c1d674 5046 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5047 (unsigned long) section->sh_size,
5048 printable_section_name (section),
5049 (unsigned long) section->sh_entsize);
ba5cdace 5050 goto exit_point;
dd24e3da
NC		 5051 }
5052
3f5e193b
NC		 5053 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5054 section->sh_size, _("symbols"));
dd24e3da 5055 if (esyms == NULL)
ba5cdace 5056 goto exit_point;
252b5132 5057
6a40cf0c
NC		 5058 {
5059 elf_section_list * entry;
5060
5061 shndx = NULL;
5062 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5063 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5064 {
6a40cf0c
NC		 5065 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5066 entry->hdr->sh_offset,
5067 1, entry->hdr->sh_size,
5068 _("symbol table section indicies"));
5069 if (shndx == NULL)
5070 goto exit_point;
5071 /* PR17531: file: heap-buffer-overflow */
5072 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5073 {
5074 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5075 printable_section_name (entry->hdr),
5076 (unsigned long) entry->hdr->sh_size,
5077 (unsigned long) section->sh_size);
5078 goto exit_point;
5079 }
c9c1d674 5080 }
6a40cf0c 5081 }
9ad5cbcf 5082
3f5e193b 5083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5084
5085 if (isyms == NULL)
5086 {
8b73c356
NC		 5087 error (_("Out of memory reading %lu symbols\n"),
5088 (unsigned long) number);
dd24e3da 5089 goto exit_point;
252b5132
RH		 5090 }
5091
dd24e3da 5092 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5093 {
5094 psym->st_name = BYTE_GET (esyms[j].st_name);
5095 psym->st_value = BYTE_GET (esyms[j].st_value);
5096 psym->st_size = BYTE_GET (esyms[j].st_size);
5097 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5098 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5099 psym->st_shndx
5100 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5101 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5102 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5103 psym->st_info = BYTE_GET (esyms[j].st_info);
5104 psym->st_other = BYTE_GET (esyms[j].st_other);
5105 }
5106
dd24e3da 5107 exit_point:
ba5cdace 5108 if (shndx != NULL)
9ad5cbcf 5109 free (shndx);
ba5cdace 5110 if (esyms != NULL)
dd24e3da 5111 free (esyms);
252b5132 5112
ba5cdace
NC		 5113 if (num_syms_return != NULL)
5114 * num_syms_return = isyms == NULL ? 0 : number;
5115
252b5132
RH		 5116 return isyms;
5117}
5118
9ea033b2 5119static Elf_Internal_Sym *
ba5cdace
NC		 5120get_64bit_elf_symbols (FILE * file,
5121 Elf_Internal_Shdr * section,
5122 unsigned long * num_syms_return)
9ea033b2 5123{
ba5cdace
NC		 5124 unsigned long number = 0;
5125 Elf64_External_Sym * esyms = NULL;
5126 Elf_External_Sym_Shndx * shndx = NULL;
5127 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5128 Elf_Internal_Sym * psym;
b34976b6 5129 unsigned int j;
9ea033b2 5130
c9c1d674
EG		 5131 if (section->sh_size == 0)
5132 {
5133 if (num_syms_return != NULL)
5134 * num_syms_return = 0;
5135 return NULL;
5136 }
5137
dd24e3da 5138 /* Run some sanity checks first. */
c9c1d674 5139 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5140 {
c9c1d674 5141 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5142 printable_section_name (section),
5143 (unsigned long) section->sh_entsize);
ba5cdace 5144 goto exit_point;
dd24e3da
NC		 5145 }
5146
f54498b4
NC		 5147 if (section->sh_size > current_file_size)
5148 {
5149 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5150 printable_section_name (section),
5151 (unsigned long) section->sh_size);
f54498b4
NC		 5152 goto exit_point;
5153 }
5154
dd24e3da
NC		 5155 number = section->sh_size / section->sh_entsize;
5156
5157 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5158 {
c9c1d674 5159 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5160 (unsigned long) section->sh_size,
5161 printable_section_name (section),
5162 (unsigned long) section->sh_entsize);
ba5cdace 5163 goto exit_point;
dd24e3da
NC		 5164 }
5165
3f5e193b
NC		 5166 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5167 section->sh_size, _("symbols"));
a6e9f9df 5168 if (!esyms)
ba5cdace 5169 goto exit_point;
9ea033b2 5170
6a40cf0c
NC		 5171 {
5172 elf_section_list * entry;
5173
5174 shndx = NULL;
5175 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5176 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5177 {
6a40cf0c
NC		 5178 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5179 entry->hdr->sh_offset,
5180 1, entry->hdr->sh_size,
5181 _("symbol table section indicies"));
5182 if (shndx == NULL)
5183 goto exit_point;
5184 /* PR17531: file: heap-buffer-overflow */
5185 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5186 {
5187 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5188 printable_section_name (entry->hdr),
5189 (unsigned long) entry->hdr->sh_size,
5190 (unsigned long) section->sh_size);
5191 goto exit_point;
5192 }
c9c1d674 5193 }
6a40cf0c 5194 }
9ad5cbcf 5195
3f5e193b 5196 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5197
5198 if (isyms == NULL)
5199 {
8b73c356
NC		 5200 error (_("Out of memory reading %lu symbols\n"),
5201 (unsigned long) number);
ba5cdace 5202 goto exit_point;
9ea033b2
NC		 5203 }
5204
ba5cdace 5205 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5206 {
5207 psym->st_name = BYTE_GET (esyms[j].st_name);
5208 psym->st_info = BYTE_GET (esyms[j].st_info);
5209 psym->st_other = BYTE_GET (esyms[j].st_other);
5210 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5211
4fbb74a6 5212 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5213 psym->st_shndx
5214 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5215 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5216 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5217
66543521
AM		 5218 psym->st_value = BYTE_GET (esyms[j].st_value);
5219 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5220 }
5221
ba5cdace
NC		 5222 exit_point:
5223 if (shndx != NULL)
9ad5cbcf 5224 free (shndx);
ba5cdace
NC		 5225 if (esyms != NULL)
5226 free (esyms);
5227
5228 if (num_syms_return != NULL)
5229 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5230
5231 return isyms;
5232}
5233
d1133906 5234static const char *
d3ba0551 5235get_elf_section_flags (bfd_vma sh_flags)
d1133906 5236{
5477e8a0 5237 static char buff[1024];
2cf0635d 5238 char * p = buff;
8d5ff12c 5239 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5240 int sindex;
5241 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5242 bfd_vma os_flags = 0;
5243 bfd_vma proc_flags = 0;
5244 bfd_vma unknown_flags = 0;
148b93f2 5245 static const struct
5477e8a0 5246 {
2cf0635d 5247 const char * str;
5477e8a0
L		 5248 int len;
5249 }
5250 flags [] =
5251 {
cfcac11d
NC		 5252 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5253 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5254 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5255 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5256 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5257 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5258 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5259 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5260 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5261 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5262 /* IA-64 specific. */
5263 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5264 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5265 /* IA-64 OpenVMS specific. */
5266 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5267 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5268 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5269 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5270 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5271 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5272 /* Generic. */
cfcac11d 5273 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5274 /* SPARC specific. */
77115a4a
L		 5275 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5276 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5277 };
5278
5279 if (do_section_details)
5280 {
8d5ff12c
L		 5281 sprintf (buff, "[%*.*lx]: ",
5282 field_size, field_size, (unsigned long) sh_flags);
5283 p += field_size + 4;
5477e8a0 5284 }
76da6bbe 5285
d1133906
NC		 5286 while (sh_flags)
5287 {
5288 bfd_vma flag;
5289
5290 flag = sh_flags & - sh_flags;
5291 sh_flags &= ~ flag;
76da6bbe 5292
5477e8a0 5293 if (do_section_details)
d1133906 5294 {
5477e8a0
L		 5295 switch (flag)
5296 {
91d6fa6a
NC		 5297 case SHF_WRITE: sindex = 0; break;
5298 case SHF_ALLOC: sindex = 1; break;
5299 case SHF_EXECINSTR: sindex = 2; break;
5300 case SHF_MERGE: sindex = 3; break;
5301 case SHF_STRINGS: sindex = 4; break;
5302 case SHF_INFO_LINK: sindex = 5; break;
5303 case SHF_LINK_ORDER: sindex = 6; break;
5304 case SHF_OS_NONCONFORMING: sindex = 7; break;
5305 case SHF_GROUP: sindex = 8; break;
5306 case SHF_TLS: sindex = 9; break;
18ae9cc1 5307 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5308 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5309
5477e8a0 5310 default:
91d6fa6a 5311 sindex = -1;
cfcac11d 5312 switch (elf_header.e_machine)
148b93f2 5313 {
cfcac11d 5314 case EM_IA_64:
148b93f2 5315 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5316 sindex = 10;
148b93f2 5317 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5318 sindex = 11;
148b93f2
NC		 5319#ifdef BFD64
5320 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5321 switch (flag)
5322 {
91d6fa6a
NC		 5323 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5324 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5325 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5326 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5327 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5328 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5329 default: break;
5330 }
5331#endif
cfcac11d
NC		 5332 break;
5333
caa83f8b 5334 case EM_386:
22abe556 5335 case EM_IAMCU:
caa83f8b 5336 case EM_X86_64:
7f502d6c 5337 case EM_L1OM:
7a9068fe 5338 case EM_K1OM:
cfcac11d
NC		 5339 case EM_OLD_SPARCV9:
5340 case EM_SPARC32PLUS:
5341 case EM_SPARCV9:
5342 case EM_SPARC:
18ae9cc1 5343 if (flag == SHF_ORDERED)
91d6fa6a 5344 sindex = 19;
cfcac11d
NC		 5345 break;
5346 default:
5347 break;
148b93f2 5348 }
5477e8a0
L		 5349 }
5350
91d6fa6a 5351 if (sindex != -1)
5477e8a0 5352 {
8d5ff12c
L		 5353 if (p != buff + field_size + 4)
5354 {
5355 if (size < (10 + 2))
bee0ee85
NC		 5356 {
5357 warn (_("Internal error: not enough buffer room for section flag info"));
5358 return _("<unknown>");
5359 }
8d5ff12c
L		 5360 size -= 2;
5361 *p++ = ',';
5362 *p++ = ' ';
5363 }
5364
91d6fa6a
NC		 5365 size -= flags [sindex].len;
5366 p = stpcpy (p, flags [sindex].str);
5477e8a0 5367 }
3b22753a 5368 else if (flag & SHF_MASKOS)
8d5ff12c 5369 os_flags |= flag;
d1133906 5370 else if (flag & SHF_MASKPROC)
8d5ff12c 5371 proc_flags |= flag;
d1133906 5372 else
8d5ff12c 5373 unknown_flags |= flag;
5477e8a0
L		 5374 }
5375 else
5376 {
5377 switch (flag)
5378 {
5379 case SHF_WRITE: *p = 'W'; break;
5380 case SHF_ALLOC: *p = 'A'; break;
5381 case SHF_EXECINSTR: *p = 'X'; break;
5382 case SHF_MERGE: *p = 'M'; break;
5383 case SHF_STRINGS: *p = 'S'; break;
5384 case SHF_INFO_LINK: *p = 'I'; break;
5385 case SHF_LINK_ORDER: *p = 'L'; break;
5386 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5387 case SHF_GROUP: *p = 'G'; break;
5388 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5389 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5390 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5391
5392 default:
8a9036a4 5393 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5394 || elf_header.e_machine == EM_L1OM
5395 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5396 && flag == SHF_X86_64_LARGE)
5397 *p = 'l';
5398 else if (flag & SHF_MASKOS)
5399 {
5400 *p = 'o';
5401 sh_flags &= ~ SHF_MASKOS;
5402 }
5403 else if (flag & SHF_MASKPROC)
5404 {
5405 *p = 'p';
5406 sh_flags &= ~ SHF_MASKPROC;
5407 }
5408 else
5409 *p = 'x';
5410 break;
5411 }
5412 p++;
d1133906
NC		 5413 }
5414 }
76da6bbe 5415
8d5ff12c
L		 5416 if (do_section_details)
5417 {
5418 if (os_flags)
5419 {
5420 size -= 5 + field_size;
5421 if (p != buff + field_size + 4)
5422 {
5423 if (size < (2 + 1))
bee0ee85
NC		 5424 {
5425 warn (_("Internal error: not enough buffer room for section flag info"));
5426 return _("<unknown>");
5427 }
8d5ff12c
L		 5428 size -= 2;
5429 *p++ = ',';
5430 *p++ = ' ';
5431 }
5432 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5433 (unsigned long) os_flags);
5434 p += 5 + field_size;
5435 }
5436 if (proc_flags)
5437 {
5438 size -= 7 + field_size;
5439 if (p != buff + field_size + 4)
5440 {
5441 if (size < (2 + 1))
bee0ee85
NC		 5442 {
5443 warn (_("Internal error: not enough buffer room for section flag info"));
5444 return _("<unknown>");
5445 }
8d5ff12c
L		 5446 size -= 2;
5447 *p++ = ',';
5448 *p++ = ' ';
5449 }
5450 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5451 (unsigned long) proc_flags);
5452 p += 7 + field_size;
5453 }
5454 if (unknown_flags)
5455 {
5456 size -= 10 + field_size;
5457 if (p != buff + field_size + 4)
5458 {
5459 if (size < (2 + 1))
bee0ee85
NC		 5460 {
5461 warn (_("Internal error: not enough buffer room for section flag info"));
5462 return _("<unknown>");
5463 }
8d5ff12c
L		 5464 size -= 2;
5465 *p++ = ',';
5466 *p++ = ' ';
5467 }
2b692964 5468 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5469 (unsigned long) unknown_flags);
5470 p += 10 + field_size;
5471 }
5472 }
5473
e9e44622 5474 *p = '\0';
d1133906
NC		 5475 return buff;
5476}
5477
77115a4a
L		 5478static unsigned int
5479get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5480{
5481 if (is_32bit_elf)
5482 {
5483 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5484 chdr->ch_type = BYTE_GET (echdr->ch_type);
5485 chdr->ch_size = BYTE_GET (echdr->ch_size);
5486 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5487 return sizeof (*echdr);
5488 }
5489 else
5490 {
5491 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5492 chdr->ch_type = BYTE_GET (echdr->ch_type);
5493 chdr->ch_size = BYTE_GET (echdr->ch_size);
5494 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5495 return sizeof (*echdr);
5496 }
5497}
5498
252b5132 5499static int
2cf0635d 5500process_section_headers (FILE * file)
252b5132 5501{
2cf0635d 5502 Elf_Internal_Shdr * section;
b34976b6 5503 unsigned int i;
252b5132
RH		 5504
5505 section_headers = NULL;
5506
5507 if (elf_header.e_shnum == 0)
5508 {
82f2dbf7
NC		 5509 /* PR binutils/12467. */
5510 if (elf_header.e_shoff != 0)
5511 warn (_("possibly corrupt ELF file header - it has a non-zero"
5512 " section header offset, but no section headers\n"));
5513 else if (do_sections)
252b5132
RH		 5514 printf (_("\nThere are no sections in this file.\n"));
5515
5516 return 1;
5517 }
5518
5519 if (do_sections && !do_header)
9ea033b2 5520 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5521 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5522
9ea033b2
NC		 5523 if (is_32bit_elf)
5524 {
049b0c3a 5525 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5526 return 0;
5527 }
049b0c3a 5528 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5529 return 0;
5530
5531 /* Read in the string table, so that we have names to display. */
0b49d371 5532 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5533 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5534 {
4fbb74a6 5535 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5536
c256ffe7
JJ		 5537 if (section->sh_size != 0)
5538 {
3f5e193b
NC		 5539 string_table = (char *) get_data (NULL, file, section->sh_offset,
5540 1, section->sh_size,
5541 _("string table"));
0de14b54 5542
c256ffe7
JJ		 5543 string_table_length = string_table != NULL ? section->sh_size : 0;
5544 }
252b5132
RH		 5545 }
5546
5547 /* Scan the sections for the dynamic symbol table
e3c8793a 5548 and dynamic string table and debug sections. */
252b5132
RH		 5549 dynamic_symbols = NULL;
5550 dynamic_strings = NULL;
5551 dynamic_syminfo = NULL;
6a40cf0c 5552 symtab_shndx_list = NULL;
103f02d3 5553
89fac5e3
RS		 5554 eh_addr_size = is_32bit_elf ? 4 : 8;
5555 switch (elf_header.e_machine)
5556 {
5557 case EM_MIPS:
5558 case EM_MIPS_RS3_LE:
5559 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5560 FDE addresses. However, the ABI also has a semi-official ILP32
5561 variant for which the normal FDE address size rules apply.
5562
5563 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5564 section, where XX is the size of longs in bits. Unfortunately,
5565 earlier compilers provided no way of distinguishing ILP32 objects
5566 from LP64 objects, so if there's any doubt, we should assume that
5567 the official LP64 form is being used. */
5568 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5569 && find_section (".gcc_compiled_long32") == NULL)
5570 eh_addr_size = 8;
5571 break;
0f56a26a
DD		 5572
5573 case EM_H8_300:
5574 case EM_H8_300H:
5575 switch (elf_header.e_flags & EF_H8_MACH)
5576 {
5577 case E_H8_MACH_H8300:
5578 case E_H8_MACH_H8300HN:
5579 case E_H8_MACH_H8300SN:
5580 case E_H8_MACH_H8300SXN:
5581 eh_addr_size = 2;
5582 break;
5583 case E_H8_MACH_H8300H:
5584 case E_H8_MACH_H8300S:
5585 case E_H8_MACH_H8300SX:
5586 eh_addr_size = 4;
5587 break;
5588 }
f4236fe4
DD		 5589 break;
5590
ff7eeb89 5591 case EM_M32C_OLD:
f4236fe4
DD		 5592 case EM_M32C:
5593 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5594 {
5595 case EF_M32C_CPU_M16C:
5596 eh_addr_size = 2;
5597 break;
5598 }
5599 break;
89fac5e3
RS		 5600 }
5601
76ca31c0
NC		 5602#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5603 do \
5604 { \
5605 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5606 if (section->sh_entsize != expected_entsize) \
9dd3a467 5607 { \
76ca31c0
NC		 5608 char buf[40]; \
5609 sprintf_vma (buf, section->sh_entsize); \
5610 /* Note: coded this way so that there is a single string for \
5611 translation. */ \
5612 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5613 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5614 (unsigned) expected_entsize); \
9dd3a467 5615 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5616 } \
5617 } \
08d8fa11 5618 while (0)
9dd3a467
NC		 5619
5620#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5621 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5622 sizeof (Elf64_External_##type))
5623
252b5132
RH		 5624 for (i = 0, section = section_headers;
5625 i < elf_header.e_shnum;
b34976b6 5626 i++, section++)
252b5132 5627 {
2cf0635d 5628 char * name = SECTION_NAME (section);
252b5132
RH		 5629
5630 if (section->sh_type == SHT_DYNSYM)
5631 {
5632 if (dynamic_symbols != NULL)
5633 {
5634 error (_("File contains multiple dynamic symbol tables\n"));
5635 continue;
5636 }
5637
08d8fa11 5638 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5639 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5640 }
5641 else if (section->sh_type == SHT_STRTAB
18bd398b 5642 && streq (name, ".dynstr"))
252b5132
RH		 5643 {
5644 if (dynamic_strings != NULL)
5645 {
5646 error (_("File contains multiple dynamic string tables\n"));
5647 continue;
5648 }
5649
3f5e193b
NC		 5650 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5651 1, section->sh_size,
5652 _("dynamic strings"));
59245841 5653 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5654 }
9ad5cbcf
AM		 5655 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5656 {
6a40cf0c
NC		 5657 elf_section_list * entry = xmalloc (sizeof * entry);
5658 entry->hdr = section;
5659 entry->next = symtab_shndx_list;
5660 symtab_shndx_list = entry;
9ad5cbcf 5661 }
08d8fa11
JJ		 5662 else if (section->sh_type == SHT_SYMTAB)
5663 CHECK_ENTSIZE (section, i, Sym);
5664 else if (section->sh_type == SHT_GROUP)
5665 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5666 else if (section->sh_type == SHT_REL)
5667 CHECK_ENTSIZE (section, i, Rel);
5668 else if (section->sh_type == SHT_RELA)
5669 CHECK_ENTSIZE (section, i, Rela);
252b5132 5670 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5671 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5672 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5673 || do_debug_str || do_debug_loc || do_debug_ranges
5674 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5675 && (const_strneq (name, ".debug_")
5676 || const_strneq (name, ".zdebug_")))
252b5132 5677 {
1b315056
CS		 5678 if (name[1] == 'z')
5679 name += sizeof (".zdebug_") - 1;
5680 else
5681 name += sizeof (".debug_") - 1;
252b5132
RH		 5682
5683 if (do_debugging
4723351a
CC		 5684 || (do_debug_info && const_strneq (name, "info"))
5685 || (do_debug_info && const_strneq (name, "types"))
5686 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5687 || (do_debug_lines && strcmp (name, "line") == 0)
5688 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5689 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5690 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5691 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5692 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5693 || (do_debug_aranges && const_strneq (name, "aranges"))
5694 || (do_debug_ranges && const_strneq (name, "ranges"))
5695 || (do_debug_frames && const_strneq (name, "frame"))
5696 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5697 || (do_debug_macinfo && const_strneq (name, "macro"))
5698 || (do_debug_str && const_strneq (name, "str"))
5699 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5700 || (do_debug_addr && const_strneq (name, "addr"))
5701 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5702 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5703 )
09c11c86 5704 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5705 }
a262ae96 5706 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5707 else if ((do_debugging || do_debug_info)
0112cd26 5708 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5709 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5710 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5711 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5712 else if (do_gdb_index && streq (name, ".gdb_index"))
5713 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5714 /* Trace sections for Itanium VMS. */
5715 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5716 || do_trace_aranges)
5717 && const_strneq (name, ".trace_"))
5718 {
5719 name += sizeof (".trace_") - 1;
5720
5721 if (do_debugging
5722 || (do_trace_info && streq (name, "info"))
5723 || (do_trace_abbrevs && streq (name, "abbrev"))
5724 || (do_trace_aranges && streq (name, "aranges"))
5725 )
5726 request_dump_bynumber (i, DEBUG_DUMP);
5727 }
252b5132
RH		 5728 }
5729
5730 if (! do_sections)
5731 return 1;
5732
3a1a2036
NC		 5733 if (elf_header.e_shnum > 1)
5734 printf (_("\nSection Headers:\n"));
5735 else
5736 printf (_("\nSection Header:\n"));
76da6bbe 5737
f7a99963 5738 if (is_32bit_elf)
595cf52e 5739 {
5477e8a0 5740 if (do_section_details)
595cf52e
L		 5741 {
5742 printf (_(" [Nr] Name\n"));
5477e8a0 5743 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5744 }
5745 else
5746 printf
5747 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5748 }
d974e256 5749 else if (do_wide)
595cf52e 5750 {
5477e8a0 5751 if (do_section_details)
595cf52e
L		 5752 {
5753 printf (_(" [Nr] Name\n"));
5477e8a0 5754 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5755 }
5756 else
5757 printf
5758 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5759 }
f7a99963
NC		 5760 else
5761 {
5477e8a0 5762 if (do_section_details)
595cf52e
L		 5763 {
5764 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5765 printf (_(" Type Address Offset Link\n"));
5766 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5767 }
5768 else
5769 {
5770 printf (_(" [Nr] Name Type Address Offset\n"));
5771 printf (_(" Size EntSize Flags Link Info Align\n"));
5772 }
f7a99963 5773 }
252b5132 5774
5477e8a0
L		 5775 if (do_section_details)
5776 printf (_(" Flags\n"));
5777
252b5132
RH		 5778 for (i = 0, section = section_headers;
5779 i < elf_header.e_shnum;
b34976b6 5780 i++, section++)
252b5132 5781 {
7bfd842d 5782 printf (" [%2u] ", i);
5477e8a0 5783 if (do_section_details)
74e1a04b 5784 printf ("%s\n ", printable_section_name (section));
595cf52e 5785 else
74e1a04b 5786 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5787
ea52a088
NC		 5788 printf (do_wide ? " %-15s " : " %-15.15s ",
5789 get_section_type_name (section->sh_type));
0b4362b0 5790
f7a99963
NC		 5791 if (is_32bit_elf)
5792 {
cfcac11d
NC		 5793 const char * link_too_big = NULL;
5794
f7a99963 5795 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5796
f7a99963
NC		 5797 printf ( " %6.6lx %6.6lx %2.2lx",
5798 (unsigned long) section->sh_offset,
5799 (unsigned long) section->sh_size,
5800 (unsigned long) section->sh_entsize);
d1133906 5801
5477e8a0
L		 5802 if (do_section_details)
5803 fputs (" ", stdout);
5804 else
5805 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5806
cfcac11d
NC		 5807 if (section->sh_link >= elf_header.e_shnum)
5808 {
5809 link_too_big = "";
5810 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5811 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5812 switch (elf_header.e_machine)
5813 {
caa83f8b 5814 case EM_386:
22abe556 5815 case EM_IAMCU:
caa83f8b 5816 case EM_X86_64:
7f502d6c 5817 case EM_L1OM:
7a9068fe 5818 case EM_K1OM:
cfcac11d
NC		 5819 case EM_OLD_SPARCV9:
5820 case EM_SPARC32PLUS:
5821 case EM_SPARCV9:
5822 case EM_SPARC:
5823 if (section->sh_link == (SHN_BEFORE & 0xffff))
5824 link_too_big = "BEFORE";
5825 else if (section->sh_link == (SHN_AFTER & 0xffff))
5826 link_too_big = "AFTER";
5827 break;
5828 default:
5829 break;
5830 }
5831 }
5832
5833 if (do_section_details)
5834 {
5835 if (link_too_big != NULL && * link_too_big)
5836 printf ("<%s> ", link_too_big);
5837 else
5838 printf ("%2u ", section->sh_link);
5839 printf ("%3u %2lu\n", section->sh_info,
5840 (unsigned long) section->sh_addralign);
5841 }
5842 else
5843 printf ("%2u %3u %2lu\n",
5844 section->sh_link,
5845 section->sh_info,
5846 (unsigned long) section->sh_addralign);
5847
5848 if (link_too_big && ! * link_too_big)
5849 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5850 i, section->sh_link);
f7a99963 5851 }
d974e256
JJ		 5852 else if (do_wide)
5853 {
5854 print_vma (section->sh_addr, LONG_HEX);
5855
5856 if ((long) section->sh_offset == section->sh_offset)
5857 printf (" %6.6lx", (unsigned long) section->sh_offset);
5858 else
5859 {
5860 putchar (' ');
5861 print_vma (section->sh_offset, LONG_HEX);
5862 }
5863
5864 if ((unsigned long) section->sh_size == section->sh_size)
5865 printf (" %6.6lx", (unsigned long) section->sh_size);
5866 else
5867 {
5868 putchar (' ');
5869 print_vma (section->sh_size, LONG_HEX);
5870 }
5871
5872 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5873 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5874 else
5875 {
5876 putchar (' ');
5877 print_vma (section->sh_entsize, LONG_HEX);
5878 }
5879
5477e8a0
L		 5880 if (do_section_details)
5881 fputs (" ", stdout);
5882 else
5883 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5884
72de5009 5885 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5886
5887 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5888 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5889 else
5890 {
5891 print_vma (section->sh_addralign, DEC);
5892 putchar ('\n');
5893 }
5894 }
5477e8a0 5895 else if (do_section_details)
595cf52e 5896 {
5477e8a0 5897 printf (" %-15.15s ",
595cf52e 5898 get_section_type_name (section->sh_type));
595cf52e
L		 5899 print_vma (section->sh_addr, LONG_HEX);
5900 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5901 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5902 else
5903 {
5904 printf (" ");
5905 print_vma (section->sh_offset, LONG_HEX);
5906 }
72de5009 5907 printf (" %u\n ", section->sh_link);
595cf52e 5908 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5909 putchar (' ');
595cf52e
L		 5910 print_vma (section->sh_entsize, LONG_HEX);
5911
72de5009
AM		 5912 printf (" %-16u %lu\n",
5913 section->sh_info,
595cf52e
L		 5914 (unsigned long) section->sh_addralign);
5915 }
f7a99963
NC		 5916 else
5917 {
5918 putchar (' ');
5919 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5920 if ((long) section->sh_offset == section->sh_offset)
5921 printf (" %8.8lx", (unsigned long) section->sh_offset);
5922 else
5923 {
5924 printf (" ");
5925 print_vma (section->sh_offset, LONG_HEX);
5926 }
f7a99963
NC		 5927 printf ("\n ");
5928 print_vma (section->sh_size, LONG_HEX);
5929 printf (" ");
5930 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5931
d1133906 5932 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5933
72de5009
AM		 5934 printf (" %2u %3u %lu\n",
5935 section->sh_link,
5936 section->sh_info,
f7a99963
NC		 5937 (unsigned long) section->sh_addralign);
5938 }
5477e8a0
L		 5939
5940 if (do_section_details)
77115a4a
L		 5941 {
5942 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5943 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5944 {
5945 /* Minimum section size is 12 bytes for 32-bit compression
5946 header + 12 bytes for compressed data header. */
5947 unsigned char buf[24];
5948 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5949 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5950 sizeof (buf), _("compression header")))
5951 {
5952 Elf_Internal_Chdr chdr;
5953 get_compression_header (&chdr, buf);
5954 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5955 printf (" ZLIB, ");
5956 else
5957 printf (_(" [<unknown>: 0x%x], "),
5958 chdr.ch_type);
5959 print_vma (chdr.ch_size, LONG_HEX);
5960 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5961 }
5962 }
5963 }
252b5132
RH		 5964 }
5965
5477e8a0 5966 if (!do_section_details)
3dbcc61d
NC		 5967 {
5968 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5969 || elf_header.e_machine == EM_L1OM
5970 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5971 printf (_("Key to Flags:\n\
5972 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5973 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5974 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5975 else
5976 printf (_("Key to Flags:\n\
e3c8793a 5977 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5978 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5979 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5980 }
d1133906 5981
252b5132
RH		 5982 return 1;
5983}
5984
f5842774
L		 5985static const char *
5986get_group_flags (unsigned int flags)
5987{
5988 static char buff[32];
5989 switch (flags)
5990 {
220453ec
AM		 5991 case 0:
5992 return "";
5993
f5842774 5994 case GRP_COMDAT:
220453ec 5995 return "COMDAT ";
f5842774
L		 5996
5997 default:
220453ec 5998 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5999 break;
6000 }
6001 return buff;
6002}
6003
6004static int
2cf0635d 6005process_section_groups (FILE * file)
f5842774 6006{
2cf0635d 6007 Elf_Internal_Shdr * section;
f5842774 6008 unsigned int i;
2cf0635d
NC		 6009 struct group * group;
6010 Elf_Internal_Shdr * symtab_sec;
6011 Elf_Internal_Shdr * strtab_sec;
6012 Elf_Internal_Sym * symtab;
ba5cdace 6013 unsigned long num_syms;
2cf0635d 6014 char * strtab;
c256ffe7 6015 size_t strtab_size;
d1f5c6e3
L		 6016
6017 /* Don't process section groups unless needed. */
6018 if (!do_unwind && !do_section_groups)
6019 return 1;
f5842774
L		 6020
6021 if (elf_header.e_shnum == 0)
6022 {
6023 if (do_section_groups)
82f2dbf7 6024 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6025
6026 return 1;
6027 }
6028
6029 if (section_headers == NULL)
6030 {
6031 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6032 /* PR 13622: This can happen with a corrupt ELF header. */
6033 return 0;
f5842774
L		 6034 }
6035
3f5e193b
NC		 6036 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6037 sizeof (struct group *));
e4b17d5c
L		 6038
6039 if (section_headers_groups == NULL)
6040 {
8b73c356
NC		 6041 error (_("Out of memory reading %u section group headers\n"),
6042 elf_header.e_shnum);
e4b17d5c
L		 6043 return 0;
6044 }
6045
f5842774 6046 /* Scan the sections for the group section. */
d1f5c6e3 6047 group_count = 0;
f5842774
L		 6048 for (i = 0, section = section_headers;
6049 i < elf_header.e_shnum;
6050 i++, section++)
e4b17d5c
L		 6051 if (section->sh_type == SHT_GROUP)
6052 group_count++;
6053
d1f5c6e3
L		 6054 if (group_count == 0)
6055 {
6056 if (do_section_groups)
6057 printf (_("\nThere are no section groups in this file.\n"));
6058
6059 return 1;
6060 }
6061
3f5e193b 6062 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6063
6064 if (section_groups == NULL)
6065 {
8b73c356
NC		 6066 error (_("Out of memory reading %lu groups\n"),
6067 (unsigned long) group_count);
e4b17d5c
L		 6068 return 0;
6069 }
6070
d1f5c6e3
L		 6071 symtab_sec = NULL;
6072 strtab_sec = NULL;
6073 symtab = NULL;
ba5cdace 6074 num_syms = 0;
d1f5c6e3 6075 strtab = NULL;
c256ffe7 6076 strtab_size = 0;
e4b17d5c
L		 6077 for (i = 0, section = section_headers, group = section_groups;
6078 i < elf_header.e_shnum;
6079 i++, section++)
f5842774
L		 6080 {
6081 if (section->sh_type == SHT_GROUP)
6082 {
74e1a04b
NC		 6083 const char * name = printable_section_name (section);
6084 const char * group_name;
2cf0635d
NC		 6085 unsigned char * start;
6086 unsigned char * indices;
f5842774 6087 unsigned int entry, j, size;
2cf0635d
NC		 6088 Elf_Internal_Shdr * sec;
6089 Elf_Internal_Sym * sym;
f5842774
L		 6090
6091 /* Get the symbol table. */
4fbb74a6
AM		 6092 if (section->sh_link >= elf_header.e_shnum
6093 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6094 != SHT_SYMTAB))
f5842774
L		 6095 {
6096 error (_("Bad sh_link in group section `%s'\n"), name);
6097 continue;
6098 }
d1f5c6e3
L		 6099
6100 if (symtab_sec != sec)
6101 {
6102 symtab_sec = sec;
6103 if (symtab)
6104 free (symtab);
ba5cdace 6105 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6106 }
f5842774 6107
dd24e3da
NC		 6108 if (symtab == NULL)
6109 {
6110 error (_("Corrupt header in group section `%s'\n"), name);
6111 continue;
6112 }
6113
ba5cdace
NC		 6114 if (section->sh_info >= num_syms)
6115 {
6116 error (_("Bad sh_info in group section `%s'\n"), name);
6117 continue;
6118 }
6119
f5842774
L		 6120 sym = symtab + section->sh_info;
6121
6122 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6123 {
4fbb74a6
AM		 6124 if (sym->st_shndx == 0
6125 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6126 {
6127 error (_("Bad sh_info in group section `%s'\n"), name);
6128 continue;
6129 }
ba2685cc 6130
4fbb74a6 6131 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6132 strtab_sec = NULL;
6133 if (strtab)
6134 free (strtab);
f5842774 6135 strtab = NULL;
c256ffe7 6136 strtab_size = 0;
f5842774
L		 6137 }
6138 else
6139 {
6140 /* Get the string table. */
4fbb74a6 6141 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6142 {
6143 strtab_sec = NULL;
6144 if (strtab)
6145 free (strtab);
6146 strtab = NULL;
6147 strtab_size = 0;
6148 }
6149 else if (strtab_sec
4fbb74a6 6150 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6151 {
6152 strtab_sec = sec;
6153 if (strtab)
6154 free (strtab);
071436c6 6155
3f5e193b 6156 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6157 1, strtab_sec->sh_size,
6158 _("string table"));
c256ffe7 6159 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6160 }
c256ffe7 6161 group_name = sym->st_name < strtab_size
2b692964 6162 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6163 }
6164
c9c1d674
EG		 6165 /* PR 17531: file: loop. */
6166 if (section->sh_entsize > section->sh_size)
6167 {
6168 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6169 printable_section_name (section),
8066deb1
AM		 6170 (unsigned long) section->sh_entsize,
6171 (unsigned long) section->sh_size);
c9c1d674
EG		 6172 break;
6173 }
6174
3f5e193b
NC		 6175 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6176 1, section->sh_size,
6177 _("section data"));
59245841
NC		 6178 if (start == NULL)
6179 continue;
f5842774
L		 6180
6181 indices = start;
6182 size = (section->sh_size / section->sh_entsize) - 1;
6183 entry = byte_get (indices, 4);
6184 indices += 4;
e4b17d5c
L		 6185
6186 if (do_section_groups)
6187 {
2b692964 6188 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6189 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6190
e4b17d5c
L		 6191 printf (_(" [Index] Name\n"));
6192 }
6193
6194 group->group_index = i;
6195
f5842774
L		 6196 for (j = 0; j < size; j++)
6197 {
2cf0635d 6198 struct group_list * g;
e4b17d5c 6199
f5842774
L		 6200 entry = byte_get (indices, 4);
6201 indices += 4;
6202
4fbb74a6 6203 if (entry >= elf_header.e_shnum)
391cb864 6204 {
57028622
NC		 6205 static unsigned num_group_errors = 0;
6206
6207 if (num_group_errors ++ < 10)
6208 {
6209 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6210 entry, i, elf_header.e_shnum - 1);
6211 if (num_group_errors == 10)
6212 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6213 }
391cb864
L		 6214 continue;
6215 }
391cb864 6216
4fbb74a6 6217 if (section_headers_groups [entry] != NULL)
e4b17d5c 6218 {
d1f5c6e3
L		 6219 if (entry)
6220 {
57028622
NC		 6221 static unsigned num_errs = 0;
6222
6223 if (num_errs ++ < 10)
6224 {
6225 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6226 entry, i,
6227 section_headers_groups [entry]->group_index);
6228 if (num_errs == 10)
6229 warn (_("Further error messages about already contained group sections suppressed\n"));
6230 }
d1f5c6e3
L		 6231 continue;
6232 }
6233 else
6234 {
6235 /* Intel C/C++ compiler may put section 0 in a
6236 section group. We just warn it the first time
6237 and ignore it afterwards. */
6238 static int warned = 0;
6239 if (!warned)
6240 {
6241 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6242 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6243 warned++;
6244 }
6245 }
e4b17d5c
L		 6246 }
6247
4fbb74a6 6248 section_headers_groups [entry] = group;
e4b17d5c
L		 6249
6250 if (do_section_groups)
6251 {
4fbb74a6 6252 sec = section_headers + entry;
74e1a04b 6253 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6254 }
6255
3f5e193b 6256 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6257 g->section_index = entry;
6258 g->next = group->root;
6259 group->root = g;
f5842774
L		 6260 }
6261
f5842774
L		 6262 if (start)
6263 free (start);
e4b17d5c
L		 6264
6265 group++;
f5842774
L		 6266 }
6267 }
6268
d1f5c6e3
L		 6269 if (symtab)
6270 free (symtab);
6271 if (strtab)
6272 free (strtab);
f5842774
L		 6273 return 1;
6274}
6275
28f997cf
TG		 6276/* Data used to display dynamic fixups. */
6277
6278struct ia64_vms_dynfixup
6279{
6280 bfd_vma needed_ident; /* Library ident number. */
6281 bfd_vma needed; /* Index in the dstrtab of the library name. */
6282 bfd_vma fixup_needed; /* Index of the library. */
6283 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6284 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6285};
6286
6287/* Data used to display dynamic relocations. */
6288
6289struct ia64_vms_dynimgrela
6290{
6291 bfd_vma img_rela_cnt; /* Number of relocations. */
6292 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6293};
6294
6295/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6296 library). */
6297
6298static void
6299dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6300 const char *strtab, unsigned int strtab_sz)
6301{
6302 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6303 long i;
6304 const char *lib_name;
6305
6306 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6307 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6308 _("dynamic section image fixups"));
6309 if (!imfs)
6310 return;
6311
6312 if (fixup->needed < strtab_sz)
6313 lib_name = strtab + fixup->needed;
6314 else
6315 {
6316 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6317 (unsigned long) fixup->needed);
28f997cf
TG		 6318 lib_name = "???";
6319 }
6320 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6321 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6322 printf
6323 (_("Seg Offset Type SymVec DataType\n"));
6324
6325 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6326 {
6327 unsigned int type;
6328 const char *rtype;
6329
6330 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6331 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6332 type = BYTE_GET (imfs [i].type);
6333 rtype = elf_ia64_reloc_type (type);
6334 if (rtype == NULL)
6335 printf (" 0x%08x ", type);
6336 else
6337 printf (" %-32s ", rtype);
6338 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6339 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6340 }
6341
6342 free (imfs);
6343}
6344
6345/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6346
6347static void
6348dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6349{
6350 Elf64_External_VMS_IMAGE_RELA *imrs;
6351 long i;
6352
6353 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6354 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6355 _("dynamic section image relocations"));
28f997cf
TG		 6356 if (!imrs)
6357 return;
6358
6359 printf (_("\nImage relocs\n"));
6360 printf
6361 (_("Seg Offset Type Addend Seg Sym Off\n"));
6362
6363 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6364 {
6365 unsigned int type;
6366 const char *rtype;
6367
6368 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6369 printf ("%08" BFD_VMA_FMT "x ",
6370 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6371 type = BYTE_GET (imrs [i].type);
6372 rtype = elf_ia64_reloc_type (type);
6373 if (rtype == NULL)
6374 printf ("0x%08x ", type);
6375 else
6376 printf ("%-31s ", rtype);
6377 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6378 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6379 printf ("%08" BFD_VMA_FMT "x\n",
6380 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6381 }
6382
6383 free (imrs);
6384}
6385
6386/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6387
6388static int
6389process_ia64_vms_dynamic_relocs (FILE *file)
6390{
6391 struct ia64_vms_dynfixup fixup;
6392 struct ia64_vms_dynimgrela imgrela;
6393 Elf_Internal_Dyn *entry;
6394 int res = 0;
6395 bfd_vma strtab_off = 0;
6396 bfd_vma strtab_sz = 0;
6397 char *strtab = NULL;
6398
6399 memset (&fixup, 0, sizeof (fixup));
6400 memset (&imgrela, 0, sizeof (imgrela));
6401
6402 /* Note: the order of the entries is specified by the OpenVMS specs. */
6403 for (entry = dynamic_section;
6404 entry < dynamic_section + dynamic_nent;
6405 entry++)
6406 {
6407 switch (entry->d_tag)
6408 {
6409 case DT_IA_64_VMS_STRTAB_OFFSET:
6410 strtab_off = entry->d_un.d_val;
6411 break;
6412 case DT_STRSZ:
6413 strtab_sz = entry->d_un.d_val;
6414 if (strtab == NULL)
6415 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6416 1, strtab_sz, _("dynamic string section"));
6417 break;
6418
6419 case DT_IA_64_VMS_NEEDED_IDENT:
6420 fixup.needed_ident = entry->d_un.d_val;
6421 break;
6422 case DT_NEEDED:
6423 fixup.needed = entry->d_un.d_val;
6424 break;
6425 case DT_IA_64_VMS_FIXUP_NEEDED:
6426 fixup.fixup_needed = entry->d_un.d_val;
6427 break;
6428 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6429 fixup.fixup_rela_cnt = entry->d_un.d_val;
6430 break;
6431 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6432 fixup.fixup_rela_off = entry->d_un.d_val;
6433 res++;
6434 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6435 break;
6436
6437 case DT_IA_64_VMS_IMG_RELA_CNT:
6438 imgrela.img_rela_cnt = entry->d_un.d_val;
6439 break;
6440 case DT_IA_64_VMS_IMG_RELA_OFF:
6441 imgrela.img_rela_off = entry->d_un.d_val;
6442 res++;
6443 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6444 break;
6445
6446 default:
6447 break;
6448 }
6449 }
6450
6451 if (strtab != NULL)
6452 free (strtab);
6453
6454 return res;
6455}
6456
85b1c36d 6457static struct
566b0d53 6458{
2cf0635d 6459 const char * name;
566b0d53
L		 6460 int reloc;
6461 int size;
6462 int rela;
6463} dynamic_relocations [] =
6464{
6465 { "REL", DT_REL, DT_RELSZ, FALSE },
6466 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6467 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6468};
6469
252b5132 6470/* Process the reloc section. */
18bd398b 6471
252b5132 6472static int
2cf0635d 6473process_relocs (FILE * file)
252b5132 6474{
b34976b6
AM		 6475 unsigned long rel_size;
6476 unsigned long rel_offset;
252b5132
RH		 6477
6478
6479 if (!do_reloc)
6480 return 1;
6481
6482 if (do_using_dynamic)
6483 {
566b0d53 6484 int is_rela;
2cf0635d 6485 const char * name;
566b0d53
L		 6486 int has_dynamic_reloc;
6487 unsigned int i;
0de14b54 6488
566b0d53 6489 has_dynamic_reloc = 0;
252b5132 6490
566b0d53 6491 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6492 {
566b0d53
L		 6493 is_rela = dynamic_relocations [i].rela;
6494 name = dynamic_relocations [i].name;
6495 rel_size = dynamic_info [dynamic_relocations [i].size];
6496 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6497
566b0d53
L		 6498 has_dynamic_reloc |= rel_size;
6499
6500 if (is_rela == UNKNOWN)
aa903cfb 6501 {
566b0d53
L		 6502 if (dynamic_relocations [i].reloc == DT_JMPREL)
6503 switch (dynamic_info[DT_PLTREL])
6504 {
6505 case DT_REL:
6506 is_rela = FALSE;
6507 break;
6508 case DT_RELA:
6509 is_rela = TRUE;
6510 break;
6511 }
aa903cfb 6512 }
252b5132 6513
566b0d53
L		 6514 if (rel_size)
6515 {
6516 printf
6517 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6518 name, rel_offset, rel_size);
252b5132 6519
d93f0186
NC		 6520 dump_relocations (file,
6521 offset_from_vma (file, rel_offset, rel_size),
6522 rel_size,
566b0d53 6523 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6524 dynamic_strings, dynamic_strings_length,
6525 is_rela, 1);
566b0d53 6526 }
252b5132 6527 }
566b0d53 6528
28f997cf
TG		 6529 if (is_ia64_vms ())
6530 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6531
566b0d53 6532 if (! has_dynamic_reloc)
252b5132
RH		 6533 printf (_("\nThere are no dynamic relocations in this file.\n"));
6534 }
6535 else
6536 {
2cf0635d 6537 Elf_Internal_Shdr * section;
b34976b6
AM		 6538 unsigned long i;
6539 int found = 0;
252b5132
RH		 6540
6541 for (i = 0, section = section_headers;
6542 i < elf_header.e_shnum;
b34976b6 6543 i++, section++)
252b5132
RH		 6544 {
6545 if ( section->sh_type != SHT_RELA
6546 && section->sh_type != SHT_REL)
6547 continue;
6548
6549 rel_offset = section->sh_offset;
6550 rel_size = section->sh_size;
6551
6552 if (rel_size)
6553 {
2cf0635d 6554 Elf_Internal_Shdr * strsec;
b34976b6 6555 int is_rela;
103f02d3 6556
252b5132
RH		 6557 printf (_("\nRelocation section "));
6558
6559 if (string_table == NULL)
19936277 6560 printf ("%d", section->sh_name);
252b5132 6561 else
74e1a04b 6562 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6563
6564 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6565 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6566
d79b3d50
NC		 6567 is_rela = section->sh_type == SHT_RELA;
6568
4fbb74a6
AM		 6569 if (section->sh_link != 0
6570 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6571 {
2cf0635d
NC		 6572 Elf_Internal_Shdr * symsec;
6573 Elf_Internal_Sym * symtab;
d79b3d50 6574 unsigned long nsyms;
c256ffe7 6575 unsigned long strtablen = 0;
2cf0635d 6576 char * strtab = NULL;
57346661 6577
4fbb74a6 6578 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6579 if (symsec->sh_type != SHT_SYMTAB
6580 && symsec->sh_type != SHT_DYNSYM)
6581 continue;
6582
ba5cdace 6583 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6584
af3fc3bc
AM		 6585 if (symtab == NULL)
6586 continue;
252b5132 6587
4fbb74a6
AM		 6588 if (symsec->sh_link != 0
6589 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6590 {
4fbb74a6 6591 strsec = section_headers + symsec->sh_link;
103f02d3 6592
3f5e193b 6593 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6594 1, strsec->sh_size,
6595 _("string table"));
c256ffe7
JJ		 6596 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6597 }
252b5132 6598
d79b3d50 6599 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6600 symtab, nsyms, strtab, strtablen,
6601 is_rela,
6602 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6603 if (strtab)
6604 free (strtab);
6605 free (symtab);
6606 }
6607 else
6608 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6609 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6610
6611 found = 1;
6612 }
6613 }
6614
6615 if (! found)
6616 printf (_("\nThere are no relocations in this file.\n"));
6617 }
6618
6619 return 1;
6620}
6621
4d6ed7c8
NC		 6622/* An absolute address consists of a section and an offset. If the
6623 section is NULL, the offset itself is the address, otherwise, the
6624 address equals to LOAD_ADDRESS(section) + offset. */
6625
6626struct absaddr
948f632f
DA		 6627{
6628 unsigned short section;
6629 bfd_vma offset;
6630};
4d6ed7c8 6631
1949de15
L		 6632#define ABSADDR(a) \
6633 ((a).section \
6634 ? section_headers [(a).section].sh_addr + (a).offset \
6635 : (a).offset)
6636
948f632f
DA		 6637/* Find the nearest symbol at or below ADDR. Returns the symbol
6638 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6639
4d6ed7c8 6640static void
2cf0635d 6641find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6642 unsigned long nsyms,
6643 const char * strtab,
6644 unsigned long strtab_size,
6645 struct absaddr addr,
6646 const char ** symname,
6647 bfd_vma * offset)
4d6ed7c8 6648{
d3ba0551 6649 bfd_vma dist = 0x100000;
2cf0635d 6650 Elf_Internal_Sym * sym;
948f632f
DA		 6651 Elf_Internal_Sym * beg;
6652 Elf_Internal_Sym * end;
2cf0635d 6653 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6654
0b6ae522 6655 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6656 beg = symtab;
6657 end = symtab + nsyms;
0b6ae522 6658
948f632f 6659 while (beg < end)
4d6ed7c8 6660 {
948f632f
DA		 6661 bfd_vma value;
6662
6663 sym = beg + (end - beg) / 2;
0b6ae522 6664
948f632f 6665 value = sym->st_value;
0b6ae522
DJ		 6666 REMOVE_ARCH_BITS (value);
6667
948f632f 6668 if (sym->st_name != 0
4d6ed7c8 6669 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6670 && addr.offset >= value
6671 && addr.offset - value < dist)
4d6ed7c8
NC		 6672 {
6673 best = sym;
0b6ae522 6674 dist = addr.offset - value;
4d6ed7c8
NC		 6675 if (!dist)
6676 break;
6677 }
948f632f
DA		 6678
6679 if (addr.offset < value)
6680 end = sym;
6681 else
6682 beg = sym + 1;
4d6ed7c8 6683 }
1b31d05e 6684
4d6ed7c8
NC		 6685 if (best)
6686 {
57346661 6687 *symname = (best->st_name >= strtab_size
2b692964 6688 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6689 *offset = dist;
6690 return;
6691 }
1b31d05e 6692
4d6ed7c8
NC		 6693 *symname = NULL;
6694 *offset = addr.offset;
6695}
6696
948f632f
DA		 6697static int
6698symcmp (const void *p, const void *q)
6699{
6700 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6701 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6702
6703 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6704}
6705
6706/* Process the unwind section. */
6707
6708#include "unwind-ia64.h"
6709
6710struct ia64_unw_table_entry
6711{
6712 struct absaddr start;
6713 struct absaddr end;
6714 struct absaddr info;
6715};
6716
6717struct ia64_unw_aux_info
6718{
6719 struct ia64_unw_table_entry *table; /* Unwind table. */
6720 unsigned long table_len; /* Length of unwind table. */
6721 unsigned char * info; /* Unwind info. */
6722 unsigned long info_size; /* Size of unwind info. */
6723 bfd_vma info_addr; /* Starting address of unwind info. */
6724 bfd_vma seg_base; /* Starting address of segment. */
6725 Elf_Internal_Sym * symtab; /* The symbol table. */
6726 unsigned long nsyms; /* Number of symbols. */
6727 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6728 unsigned long nfuns; /* Number of entries in funtab. */
6729 char * strtab; /* The string table. */
6730 unsigned long strtab_size; /* Size of string table. */
6731};
6732
4d6ed7c8 6733static void
2cf0635d 6734dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6735{
2cf0635d 6736 struct ia64_unw_table_entry * tp;
948f632f 6737 unsigned long j, nfuns;
4d6ed7c8 6738 int in_body;
7036c0e1 6739
948f632f
DA		 6740 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6741 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6742 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6743 aux->funtab[nfuns++] = aux->symtab[j];
6744 aux->nfuns = nfuns;
6745 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6746
4d6ed7c8
NC		 6747 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6748 {
6749 bfd_vma stamp;
6750 bfd_vma offset;
2cf0635d
NC		 6751 const unsigned char * dp;
6752 const unsigned char * head;
53774b7e 6753 const unsigned char * end;
2cf0635d 6754 const char * procname;
4d6ed7c8 6755
948f632f 6756 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6757 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6758
6759 fputs ("\n<", stdout);
6760
6761 if (procname)
6762 {
6763 fputs (procname, stdout);
6764
6765 if (offset)
6766 printf ("+%lx", (unsigned long) offset);
6767 }
6768
6769 fputs (">: [", stdout);
6770 print_vma (tp->start.offset, PREFIX_HEX);
6771 fputc ('-', stdout);
6772 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6773 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6774 (unsigned long) (tp->info.offset - aux->seg_base));
6775
53774b7e
NC		 6776 /* PR 17531: file: 86232b32. */
6777 if (aux->info == NULL)
6778 continue;
6779
6780 /* PR 17531: file: 0997b4d1. */
6781 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6782 {
6783 warn (_("Invalid offset %lx in table entry %ld\n"),
6784 (long) tp->info.offset, (long) (tp - aux->table));
6785 continue;
6786 }
6787
1949de15 6788 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6789 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6790
86f55779 6791 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6792 (unsigned) UNW_VER (stamp),
6793 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6794 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6795 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6796 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6797
6798 if (UNW_VER (stamp) != 1)
6799 {
2b692964 6800 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6801 continue;
6802 }
6803
6804 in_body = 0;
53774b7e
NC		 6805 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6806 /* PR 17531: file: 16ceda89. */
6807 if (end > aux->info + aux->info_size)
6808 end = aux->info + aux->info_size;
6809 for (dp = head + 8; dp < end;)
b4477bc8 6810 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6811 }
948f632f
DA		 6812
6813 free (aux->funtab);
4d6ed7c8
NC		 6814}
6815
53774b7e 6816static bfd_boolean
2cf0635d
NC		 6817slurp_ia64_unwind_table (FILE * file,
6818 struct ia64_unw_aux_info * aux,
6819 Elf_Internal_Shdr * sec)
4d6ed7c8 6820{
89fac5e3 6821 unsigned long size, nrelas, i;
2cf0635d
NC		 6822 Elf_Internal_Phdr * seg;
6823 struct ia64_unw_table_entry * tep;
6824 Elf_Internal_Shdr * relsec;
6825 Elf_Internal_Rela * rela;
6826 Elf_Internal_Rela * rp;
6827 unsigned char * table;
6828 unsigned char * tp;
6829 Elf_Internal_Sym * sym;
6830 const char * relname;
4d6ed7c8 6831
53774b7e
NC		 6832 aux->table_len = 0;
6833
4d6ed7c8
NC		 6834 /* First, find the starting address of the segment that includes
6835 this section: */
6836
6837 if (elf_header.e_phnum)
6838 {
d93f0186 6839 if (! get_program_headers (file))
53774b7e 6840 return FALSE;
4d6ed7c8 6841
d93f0186
NC		 6842 for (seg = program_headers;
6843 seg < program_headers + elf_header.e_phnum;
6844 ++seg)
4d6ed7c8
NC		 6845 {
6846 if (seg->p_type != PT_LOAD)
6847 continue;
6848
6849 if (sec->sh_addr >= seg->p_vaddr
6850 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6851 {
6852 aux->seg_base = seg->p_vaddr;
6853 break;
6854 }
6855 }
4d6ed7c8
NC		 6856 }
6857
6858 /* Second, build the unwind table from the contents of the unwind section: */
6859 size = sec->sh_size;
3f5e193b
NC		 6860 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6861 _("unwind table"));
a6e9f9df 6862 if (!table)
53774b7e 6863 return FALSE;
4d6ed7c8 6864
53774b7e 6865 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6866 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6867 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6868 tep = aux->table;
53774b7e
NC		 6869
6870 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6871 {
6872 tep->start.section = SHN_UNDEF;
6873 tep->end.section = SHN_UNDEF;
6874 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6875 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6876 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6877 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6878 tep->start.offset += aux->seg_base;
6879 tep->end.offset += aux->seg_base;
6880 tep->info.offset += aux->seg_base;
6881 }
6882 free (table);
6883
41e92641 6884 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6885 for (relsec = section_headers;
6886 relsec < section_headers + elf_header.e_shnum;
6887 ++relsec)
6888 {
6889 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6890 || relsec->sh_info >= elf_header.e_shnum
6891 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6892 continue;
6893
6894 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6895 & rela, & nrelas))
53774b7e
NC		 6896 {
6897 free (aux->table);
6898 aux->table = NULL;
6899 aux->table_len = 0;
6900 return FALSE;
6901 }
4d6ed7c8
NC		 6902
6903 for (rp = rela; rp < rela + nrelas; ++rp)
6904 {
aca88567
NC		 6905 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6906 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6907
82b1b41b
NC		 6908 /* PR 17531: file: 9fa67536. */
6909 if (relname == NULL)
6910 {
6911 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6912 continue;
6913 }
948f632f 6914
0112cd26 6915 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6916 {
82b1b41b 6917 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6918 continue;
6919 }
6920
89fac5e3 6921 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6922
53774b7e
NC		 6923 /* PR 17531: file: 5bc8d9bf. */
6924 if (i >= aux->table_len)
6925 {
6926 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6927 continue;
6928 }
6929
6930 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6931 {
6932 case 0:
6933 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6934 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6935 break;
6936 case 1:
6937 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6938 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6939 break;
6940 case 2:
6941 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6942 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6943 break;
6944 default:
6945 break;
6946 }
6947 }
6948
6949 free (rela);
6950 }
6951
53774b7e 6952 return TRUE;
4d6ed7c8
NC		 6953}
6954
1b31d05e 6955static void
2cf0635d 6956ia64_process_unwind (FILE * file)
4d6ed7c8 6957{
2cf0635d
NC		 6958 Elf_Internal_Shdr * sec;
6959 Elf_Internal_Shdr * unwsec = NULL;
6960 Elf_Internal_Shdr * strsec;
89fac5e3 6961 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6962 struct ia64_unw_aux_info aux;
f1467e33 6963
4d6ed7c8
NC		 6964 memset (& aux, 0, sizeof (aux));
6965
4d6ed7c8
NC		 6966 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6967 {
c256ffe7 6968 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6969 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6970 {
ba5cdace 6971 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6972
4fbb74a6 6973 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6974 if (aux.strtab != NULL)
6975 {
6976 error (_("Multiple auxillary string tables encountered\n"));
6977 free (aux.strtab);
6978 }
3f5e193b
NC		 6979 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6980 1, strsec->sh_size,
6981 _("string table"));
c256ffe7 6982 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6983 }
6984 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6985 unwcount++;
6986 }
6987
6988 if (!unwcount)
6989 printf (_("\nThere are no unwind sections in this file.\n"));
6990
6991 while (unwcount-- > 0)
6992 {
2cf0635d 6993 char * suffix;
579f31ac
JJ		 6994 size_t len, len2;
6995
4082ef84 6996 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6997 i < elf_header.e_shnum; ++i, ++sec)
6998 if (sec->sh_type == SHT_IA_64_UNWIND)
6999 {
7000 unwsec = sec;
7001 break;
7002 }
4082ef84
NC		 7003 /* We have already counted the number of SHT_IA64_UNWIND
7004 sections so the loop above should never fail. */
7005 assert (unwsec != NULL);
579f31ac
JJ		 7006
7007 unwstart = i + 1;
7008 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7009
e4b17d5c
L		 7010 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7011 {
7012 /* We need to find which section group it is in. */
4082ef84 7013 struct group_list * g;
e4b17d5c 7014
4082ef84
NC		 7015 if (section_headers_groups == NULL
7016 || section_headers_groups [i] == NULL)
7017 i = elf_header.e_shnum;
7018 else
e4b17d5c 7019 {
4082ef84 7020 g = section_headers_groups [i]->root;
18bd398b 7021
4082ef84
NC		 7022 for (; g != NULL; g = g->next)
7023 {
7024 sec = section_headers + g->section_index;
e4b17d5c 7025
4082ef84
NC		 7026 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7027 break;
7028 }
7029
7030 if (g == NULL)
7031 i = elf_header.e_shnum;
7032 }
e4b17d5c 7033 }
18bd398b 7034 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7035 {
18bd398b 7036 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7037 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7038 suffix = SECTION_NAME (unwsec) + len;
7039 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7040 ++i, ++sec)
18bd398b
NC		 7041 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7042 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7043 break;
7044 }
7045 else
7046 {
7047 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7048 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7049 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7050 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7051 suffix = "";
18bd398b 7052 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7053 suffix = SECTION_NAME (unwsec) + len;
7054 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7055 ++i, ++sec)
18bd398b
NC		 7056 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7057 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7058 break;
7059 }
7060
7061 if (i == elf_header.e_shnum)
7062 {
7063 printf (_("\nCould not find unwind info section for "));
7064
7065 if (string_table == NULL)
7066 printf ("%d", unwsec->sh_name);
7067 else
74e1a04b 7068 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7069 }
7070 else
4d6ed7c8 7071 {
4d6ed7c8 7072 aux.info_addr = sec->sh_addr;
3f5e193b 7073 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7074 sec->sh_size,
7075 _("unwind info"));
59245841 7076 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7077
579f31ac 7078 printf (_("\nUnwind section "));
4d6ed7c8 7079
579f31ac
JJ		 7080 if (string_table == NULL)
7081 printf ("%d", unwsec->sh_name);
7082 else
74e1a04b 7083 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7084
579f31ac 7085 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7086 (unsigned long) unwsec->sh_offset,
89fac5e3 7087 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7088
53774b7e
NC		 7089 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7090 && aux.table_len > 0)
579f31ac
JJ		 7091 dump_ia64_unwind (& aux);
7092
7093 if (aux.table)
7094 free ((char *) aux.table);
7095 if (aux.info)
7096 free ((char *) aux.info);
7097 aux.table = NULL;
7098 aux.info = NULL;
7099 }
4d6ed7c8 7100 }
4d6ed7c8 7101
4d6ed7c8
NC		 7102 if (aux.symtab)
7103 free (aux.symtab);
7104 if (aux.strtab)
7105 free ((char *) aux.strtab);
4d6ed7c8
NC		 7106}
7107
3f5e193b
NC		 7108struct hppa_unw_table_entry
7109 {
7110 struct absaddr start;
7111 struct absaddr end;
948f632f 7112 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7113 unsigned int Millicode:1; /* 1 */
7114 unsigned int Millicode_save_sr0:1; /* 2 */
7115 unsigned int Region_description:2; /* 3..4 */
7116 unsigned int reserved1:1; /* 5 */
7117 unsigned int Entry_SR:1; /* 6 */
7118 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7119 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7120 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7121 unsigned int Variable_Frame:1; /* 17 */
7122 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7123 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7124 unsigned int Stack_Overflow_Check:1; /* 20 */
7125 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7126 unsigned int Ada_Region:1; /* 22 */
7127 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7128 unsigned int cxx_try_catch:1; /* 24 */
7129 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7130 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7131 unsigned int Save_SP:1; /* 27 */
7132 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7133 unsigned int Save_MRP_in_frame:1; /* 29 */
7134 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7135 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7136
948f632f
DA		 7137 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7138 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7139 unsigned int Large_frame:1; /* 2 */
948f632f 7140 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7141 unsigned int reserved4:1; /* 4 */
7142 unsigned int Total_frame_size:27; /* 5..31 */
7143 };
7144
57346661 7145struct hppa_unw_aux_info
948f632f
DA		 7146{
7147 struct hppa_unw_table_entry * table; /* Unwind table. */
7148 unsigned long table_len; /* Length of unwind table. */
7149 bfd_vma seg_base; /* Starting address of segment. */
7150 Elf_Internal_Sym * symtab; /* The symbol table. */
7151 unsigned long nsyms; /* Number of symbols. */
7152 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7153 unsigned long nfuns; /* Number of entries in funtab. */
7154 char * strtab; /* The string table. */
7155 unsigned long strtab_size; /* Size of string table. */
7156};
57346661
AM		 7157
7158static void
2cf0635d 7159dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7160{
2cf0635d 7161 struct hppa_unw_table_entry * tp;
948f632f
DA		 7162 unsigned long j, nfuns;
7163
7164 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7165 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7166 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7167 aux->funtab[nfuns++] = aux->symtab[j];
7168 aux->nfuns = nfuns;
7169 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7170
57346661
AM		 7171 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7172 {
7173 bfd_vma offset;
2cf0635d 7174 const char * procname;
57346661 7175
948f632f 7176 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7177 aux->strtab_size, tp->start, &procname,
7178 &offset);
7179
7180 fputs ("\n<", stdout);
7181
7182 if (procname)
7183 {
7184 fputs (procname, stdout);
7185
7186 if (offset)
7187 printf ("+%lx", (unsigned long) offset);
7188 }
7189
7190 fputs (">: [", stdout);
7191 print_vma (tp->start.offset, PREFIX_HEX);
7192 fputc ('-', stdout);
7193 print_vma (tp->end.offset, PREFIX_HEX);
7194 printf ("]\n\t");
7195
18bd398b
NC		 7196#define PF(_m) if (tp->_m) printf (#_m " ");
7197#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7198 PF(Cannot_unwind);
7199 PF(Millicode);
7200 PF(Millicode_save_sr0);
18bd398b 7201 /* PV(Region_description); */
57346661
AM		 7202 PF(Entry_SR);
7203 PV(Entry_FR);
7204 PV(Entry_GR);
7205 PF(Args_stored);
7206 PF(Variable_Frame);
7207 PF(Separate_Package_Body);
7208 PF(Frame_Extension_Millicode);
7209 PF(Stack_Overflow_Check);
7210 PF(Two_Instruction_SP_Increment);
7211 PF(Ada_Region);
7212 PF(cxx_info);
7213 PF(cxx_try_catch);
7214 PF(sched_entry_seq);
7215 PF(Save_SP);
7216 PF(Save_RP);
7217 PF(Save_MRP_in_frame);
7218 PF(extn_ptr_defined);
7219 PF(Cleanup_defined);
7220 PF(MPE_XL_interrupt_marker);
7221 PF(HP_UX_interrupt_marker);
7222 PF(Large_frame);
7223 PF(Pseudo_SP_Set);
7224 PV(Total_frame_size);
7225#undef PF
7226#undef PV
7227 }
7228
18bd398b 7229 printf ("\n");
948f632f
DA		 7230
7231 free (aux->funtab);
57346661
AM		 7232}
7233
7234static int
2cf0635d
NC		 7235slurp_hppa_unwind_table (FILE * file,
7236 struct hppa_unw_aux_info * aux,
7237 Elf_Internal_Shdr * sec)
57346661 7238{
1c0751b2 7239 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7240 Elf_Internal_Phdr * seg;
7241 struct hppa_unw_table_entry * tep;
7242 Elf_Internal_Shdr * relsec;
7243 Elf_Internal_Rela * rela;
7244 Elf_Internal_Rela * rp;
7245 unsigned char * table;
7246 unsigned char * tp;
7247 Elf_Internal_Sym * sym;
7248 const char * relname;
57346661 7249
57346661
AM		 7250 /* First, find the starting address of the segment that includes
7251 this section. */
7252
7253 if (elf_header.e_phnum)
7254 {
7255 if (! get_program_headers (file))
7256 return 0;
7257
7258 for (seg = program_headers;
7259 seg < program_headers + elf_header.e_phnum;
7260 ++seg)
7261 {
7262 if (seg->p_type != PT_LOAD)
7263 continue;
7264
7265 if (sec->sh_addr >= seg->p_vaddr
7266 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7267 {
7268 aux->seg_base = seg->p_vaddr;
7269 break;
7270 }
7271 }
7272 }
7273
7274 /* Second, build the unwind table from the contents of the unwind
7275 section. */
7276 size = sec->sh_size;
3f5e193b
NC		 7277 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7278 _("unwind table"));
57346661
AM		 7279 if (!table)
7280 return 0;
7281
1c0751b2
DA		 7282 unw_ent_size = 16;
7283 nentries = size / unw_ent_size;
7284 size = unw_ent_size * nentries;
57346661 7285
3f5e193b
NC		 7286 tep = aux->table = (struct hppa_unw_table_entry *)
7287 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7288
1c0751b2 7289 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7290 {
7291 unsigned int tmp1, tmp2;
7292
7293 tep->start.section = SHN_UNDEF;
7294 tep->end.section = SHN_UNDEF;
7295
1c0751b2
DA		 7296 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7297 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7298 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7299 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7300
7301 tep->start.offset += aux->seg_base;
7302 tep->end.offset += aux->seg_base;
57346661
AM		 7303
7304 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7305 tep->Millicode = (tmp1 >> 30) & 0x1;
7306 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7307 tep->Region_description = (tmp1 >> 27) & 0x3;
7308 tep->reserved1 = (tmp1 >> 26) & 0x1;
7309 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7310 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7311 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7312 tep->Args_stored = (tmp1 >> 15) & 0x1;
7313 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7314 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7315 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7316 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7317 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7318 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7319 tep->cxx_info = (tmp1 >> 8) & 0x1;
7320 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7321 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7322 tep->reserved2 = (tmp1 >> 5) & 0x1;
7323 tep->Save_SP = (tmp1 >> 4) & 0x1;
7324 tep->Save_RP = (tmp1 >> 3) & 0x1;
7325 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7326 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7327 tep->Cleanup_defined = tmp1 & 0x1;
7328
7329 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7330 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7331 tep->Large_frame = (tmp2 >> 29) & 0x1;
7332 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7333 tep->reserved4 = (tmp2 >> 27) & 0x1;
7334 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7335 }
7336 free (table);
7337
7338 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7339 for (relsec = section_headers;
7340 relsec < section_headers + elf_header.e_shnum;
7341 ++relsec)
7342 {
7343 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7344 || relsec->sh_info >= elf_header.e_shnum
7345 || section_headers + relsec->sh_info != sec)
57346661
AM		 7346 continue;
7347
7348 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7349 & rela, & nrelas))
7350 return 0;
7351
7352 for (rp = rela; rp < rela + nrelas; ++rp)
7353 {
aca88567
NC		 7354 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7355 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7356
7357 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7358 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7359 {
7360 warn (_("Skipping unexpected relocation type %s\n"), relname);
7361 continue;
7362 }
7363
7364 i = rp->r_offset / unw_ent_size;
7365
89fac5e3 7366 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7367 {
7368 case 0:
7369 aux->table[i].start.section = sym->st_shndx;
1e456d54 7370 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7371 break;
7372 case 1:
7373 aux->table[i].end.section = sym->st_shndx;
1e456d54 7374 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7375 break;
7376 default:
7377 break;
7378 }
7379 }
7380
7381 free (rela);
7382 }
7383
1c0751b2 7384 aux->table_len = nentries;
57346661
AM		 7385
7386 return 1;
7387}
7388
1b31d05e 7389static void
2cf0635d 7390hppa_process_unwind (FILE * file)
57346661 7391{
57346661 7392 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7393 Elf_Internal_Shdr * unwsec = NULL;
7394 Elf_Internal_Shdr * strsec;
7395 Elf_Internal_Shdr * sec;
18bd398b 7396 unsigned long i;
57346661 7397
c256ffe7 7398 if (string_table == NULL)
1b31d05e
NC		 7399 return;
7400
7401 memset (& aux, 0, sizeof (aux));
57346661
AM		 7402
7403 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7404 {
c256ffe7 7405 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7406 && sec->sh_link < elf_header.e_shnum)
57346661 7407 {
ba5cdace 7408 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7409
4fbb74a6 7410 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7411 if (aux.strtab != NULL)
7412 {
7413 error (_("Multiple auxillary string tables encountered\n"));
7414 free (aux.strtab);
7415 }
3f5e193b
NC		 7416 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7417 1, strsec->sh_size,
7418 _("string table"));
c256ffe7 7419 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7420 }
18bd398b 7421 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7422 unwsec = sec;
7423 }
7424
7425 if (!unwsec)
7426 printf (_("\nThere are no unwind sections in this file.\n"));
7427
7428 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7429 {
18bd398b 7430 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7431 {
74e1a04b
NC		 7432 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7433 printable_section_name (sec),
57346661 7434 (unsigned long) sec->sh_offset,
89fac5e3 7435 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7436
7437 slurp_hppa_unwind_table (file, &aux, sec);
7438 if (aux.table_len > 0)
7439 dump_hppa_unwind (&aux);
7440
7441 if (aux.table)
7442 free ((char *) aux.table);
7443 aux.table = NULL;
7444 }
7445 }
7446
7447 if (aux.symtab)
7448 free (aux.symtab);
7449 if (aux.strtab)
7450 free ((char *) aux.strtab);
57346661
AM		 7451}
7452
0b6ae522
DJ		 7453struct arm_section
7454{
a734115a
NC		 7455 unsigned char * data; /* The unwind data. */
7456 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7457 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7458 unsigned long nrelas; /* The number of relocations. */
7459 unsigned int rel_type; /* REL or RELA ? */
7460 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7461};
7462
7463struct arm_unw_aux_info
7464{
a734115a
NC		 7465 FILE * file; /* The file containing the unwind sections. */
7466 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7467 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7468 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7469 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7470 char * strtab; /* The file's string table. */
7471 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7472};
7473
7474static const char *
7475arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7476 bfd_vma fn, struct absaddr addr)
7477{
7478 const char *procname;
7479 bfd_vma sym_offset;
7480
7481 if (addr.section == SHN_UNDEF)
7482 addr.offset = fn;
7483
948f632f 7484 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7485 aux->strtab_size, addr, &procname,
7486 &sym_offset);
7487
7488 print_vma (fn, PREFIX_HEX);
7489
7490 if (procname)
7491 {
7492 fputs (" <", stdout);
7493 fputs (procname, stdout);
7494
7495 if (sym_offset)
7496 printf ("+0x%lx", (unsigned long) sym_offset);
7497 fputc ('>', stdout);
7498 }
7499
7500 return procname;
7501}
7502
7503static void
7504arm_free_section (struct arm_section *arm_sec)
7505{
7506 if (arm_sec->data != NULL)
7507 free (arm_sec->data);
7508
7509 if (arm_sec->rela != NULL)
7510 free (arm_sec->rela);
7511}
7512
a734115a
NC		 7513/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7514 cached section and install SEC instead.
7515 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7516 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7517 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7518 relocation's offset in ADDR.
1b31d05e
NC		 7519 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7520 into the string table of the symbol associated with the reloc. If no
7521 reloc was applied store -1 there.
7522 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7523
7524static bfd_boolean
1b31d05e
NC		 7525get_unwind_section_word (struct arm_unw_aux_info * aux,
7526 struct arm_section * arm_sec,
7527 Elf_Internal_Shdr * sec,
7528 bfd_vma word_offset,
7529 unsigned int * wordp,
7530 struct absaddr * addr,
7531 bfd_vma * sym_name)
0b6ae522
DJ		 7532{
7533 Elf_Internal_Rela *rp;
7534 Elf_Internal_Sym *sym;
7535 const char * relname;
7536 unsigned int word;
7537 bfd_boolean wrapped;
7538
e0a31db1
NC		 7539 if (sec == NULL || arm_sec == NULL)
7540 return FALSE;
7541
0b6ae522
DJ		 7542 addr->section = SHN_UNDEF;
7543 addr->offset = 0;
7544
1b31d05e
NC		 7545 if (sym_name != NULL)
7546 *sym_name = (bfd_vma) -1;
7547
a734115a 7548 /* If necessary, update the section cache. */
0b6ae522
DJ		 7549 if (sec != arm_sec->sec)
7550 {
7551 Elf_Internal_Shdr *relsec;
7552
7553 arm_free_section (arm_sec);
7554
7555 arm_sec->sec = sec;
7556 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7557 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7558 arm_sec->rela = NULL;
7559 arm_sec->nrelas = 0;
7560
7561 for (relsec = section_headers;
7562 relsec < section_headers + elf_header.e_shnum;
7563 ++relsec)
7564 {
7565 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7566 || section_headers + relsec->sh_info != sec
7567 /* PR 15745: Check the section type as well. */
7568 || (relsec->sh_type != SHT_REL
7569 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7570 continue;
7571
a734115a 7572 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7573 if (relsec->sh_type == SHT_REL)
7574 {
7575 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7576 relsec->sh_size,
7577 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7578 return FALSE;
0b6ae522 7579 }
1ae40aa4 7580 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7581 {
7582 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7583 relsec->sh_size,
7584 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7585 return FALSE;
0b6ae522 7586 }
1ae40aa4 7587 break;
0b6ae522
DJ		 7588 }
7589
7590 arm_sec->next_rela = arm_sec->rela;
7591 }
7592
a734115a 7593 /* If there is no unwind data we can do nothing. */
0b6ae522 7594 if (arm_sec->data == NULL)
a734115a 7595 return FALSE;
0b6ae522 7596
e0a31db1 7597 /* If the offset is invalid then fail. */
1a915552
NC		 7598 if (word_offset > (sec->sh_size - 4)
7599 /* PR 18879 */
7600 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7601 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7602 return FALSE;
7603
a734115a 7604 /* Get the word at the required offset. */
0b6ae522
DJ		 7605 word = byte_get (arm_sec->data + word_offset, 4);
7606
0eff7165
NC		 7607 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7608 if (arm_sec->rela == NULL)
7609 {
7610 * wordp = word;
7611 return TRUE;
7612 }
7613
a734115a 7614 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7615 wrapped = FALSE;
7616 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7617 {
7618 bfd_vma prelval, offset;
7619
7620 if (rp->r_offset > word_offset && !wrapped)
7621 {
7622 rp = arm_sec->rela;
7623 wrapped = TRUE;
7624 }
7625 if (rp->r_offset > word_offset)
7626 break;
7627
7628 if (rp->r_offset & 3)
7629 {
7630 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7631 (unsigned long) rp->r_offset);
7632 continue;
7633 }
7634
7635 if (rp->r_offset < word_offset)
7636 continue;
7637
74e1a04b
NC		 7638 /* PR 17531: file: 027-161405-0.004 */
7639 if (aux->symtab == NULL)
7640 continue;
7641
0b6ae522
DJ		 7642 if (arm_sec->rel_type == SHT_REL)
7643 {
7644 offset = word & 0x7fffffff;
7645 if (offset & 0x40000000)
7646 offset |= ~ (bfd_vma) 0x7fffffff;
7647 }
a734115a 7648 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7649 offset = rp->r_addend;
a734115a 7650 else
74e1a04b
NC		 7651 {
7652 error (_("Unknown section relocation type %d encountered\n"),
7653 arm_sec->rel_type);
7654 break;
7655 }
0b6ae522 7656
071436c6
NC		 7657 /* PR 17531 file: 027-1241568-0.004. */
7658 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7659 {
7660 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7661 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7662 break;
7663 }
7664
7665 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7666 offset += sym->st_value;
7667 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7668
a734115a
NC		 7669 /* Check that we are processing the expected reloc type. */
7670 if (elf_header.e_machine == EM_ARM)
7671 {
7672 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7673 if (relname == NULL)
7674 {
7675 warn (_("Skipping unknown ARM relocation type: %d\n"),
7676 (int) ELF32_R_TYPE (rp->r_info));
7677 continue;
7678 }
a734115a
NC		 7679
7680 if (streq (relname, "R_ARM_NONE"))
7681 continue;
0b4362b0 7682
a734115a
NC		 7683 if (! streq (relname, "R_ARM_PREL31"))
7684 {
071436c6 7685 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7686 continue;
7687 }
7688 }
7689 else if (elf_header.e_machine == EM_TI_C6000)
7690 {
7691 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7692 if (relname == NULL)
7693 {
7694 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7695 (int) ELF32_R_TYPE (rp->r_info));
7696 continue;
7697 }
0b4362b0 7698
a734115a
NC		 7699 if (streq (relname, "R_C6000_NONE"))
7700 continue;
7701
7702 if (! streq (relname, "R_C6000_PREL31"))
7703 {
071436c6 7704 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7705 continue;
7706 }
7707
7708 prelval >>= 1;
7709 }
7710 else
74e1a04b
NC		 7711 {
7712 /* This function currently only supports ARM and TI unwinders. */
7713 warn (_("Only TI and ARM unwinders are currently supported\n"));
7714 break;
7715 }
fa197c1c 7716
0b6ae522
DJ		 7717 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7718 addr->section = sym->st_shndx;
7719 addr->offset = offset;
74e1a04b 7720
1b31d05e
NC		 7721 if (sym_name)
7722 * sym_name = sym->st_name;
0b6ae522
DJ		 7723 break;
7724 }
7725
7726 *wordp = word;
7727 arm_sec->next_rela = rp;
7728
a734115a 7729 return TRUE;
0b6ae522
DJ		 7730}
7731
a734115a
NC		 7732static const char *tic6x_unwind_regnames[16] =
7733{
0b4362b0
RM		 7734 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7735 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7736 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7737};
fa197c1c 7738
0b6ae522 7739static void
fa197c1c 7740decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7741{
fa197c1c
PB		 7742 int i;
7743
7744 for (i = 12; mask; mask >>= 1, i--)
7745 {
7746 if (mask & 1)
7747 {
7748 fputs (tic6x_unwind_regnames[i], stdout);
7749 if (mask > 1)
7750 fputs (", ", stdout);
7751 }
7752 }
7753}
0b6ae522
DJ		 7754
7755#define ADVANCE \
7756 if (remaining == 0 && more_words) \
7757 { \
7758 data_offset += 4; \
1b31d05e
NC		 7759 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7760 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7761 return; \
7762 remaining = 4; \
7763 more_words--; \
7764 } \
7765
7766#define GET_OP(OP) \
7767 ADVANCE; \
7768 if (remaining) \
7769 { \
7770 remaining--; \
7771 (OP) = word >> 24; \
7772 word <<= 8; \
7773 } \
7774 else \
7775 { \
2b692964 7776 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7777 return; \
7778 } \
cc5914eb 7779 printf ("0x%02x ", OP)
0b6ae522 7780
fa197c1c 7781static void
948f632f
DA		 7782decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7783 unsigned int word,
7784 unsigned int remaining,
7785 unsigned int more_words,
7786 bfd_vma data_offset,
7787 Elf_Internal_Shdr * data_sec,
7788 struct arm_section * data_arm_sec)
fa197c1c
PB		 7789{
7790 struct absaddr addr;
0b6ae522
DJ		 7791
7792 /* Decode the unwinding instructions. */
7793 while (1)
7794 {
7795 unsigned int op, op2;
7796
7797 ADVANCE;
7798 if (remaining == 0)
7799 break;
7800 remaining--;
7801 op = word >> 24;
7802 word <<= 8;
7803
cc5914eb 7804 printf (" 0x%02x ", op);
0b6ae522
DJ		 7805
7806 if ((op & 0xc0) == 0x00)
7807 {
7808 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7809
cc5914eb 7810 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7811 }
7812 else if ((op & 0xc0) == 0x40)
7813 {
7814 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7815
cc5914eb 7816 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7817 }
7818 else if ((op & 0xf0) == 0x80)
7819 {
7820 GET_OP (op2);
7821 if (op == 0x80 && op2 == 0)
7822 printf (_("Refuse to unwind"));
7823 else
7824 {
7825 unsigned int mask = ((op & 0x0f) << 8) | op2;
7826 int first = 1;
7827 int i;
2b692964 7828
0b6ae522
DJ		 7829 printf ("pop {");
7830 for (i = 0; i < 12; i++)
7831 if (mask & (1 << i))
7832 {
7833 if (first)
7834 first = 0;
7835 else
7836 printf (", ");
7837 printf ("r%d", 4 + i);
7838 }
7839 printf ("}");
7840 }
7841 }
7842 else if ((op & 0xf0) == 0x90)
7843 {
7844 if (op == 0x9d || op == 0x9f)
7845 printf (_(" [Reserved]"));
7846 else
cc5914eb 7847 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7848 }
7849 else if ((op & 0xf0) == 0xa0)
7850 {
7851 int end = 4 + (op & 0x07);
7852 int first = 1;
7853 int i;
61865e30 7854
0b6ae522
DJ		 7855 printf (" pop {");
7856 for (i = 4; i <= end; i++)
7857 {
7858 if (first)
7859 first = 0;
7860 else
7861 printf (", ");
7862 printf ("r%d", i);
7863 }
7864 if (op & 0x08)
7865 {
1b31d05e 7866 if (!first)
0b6ae522
DJ		 7867 printf (", ");
7868 printf ("r14");
7869 }
7870 printf ("}");
7871 }
7872 else if (op == 0xb0)
7873 printf (_(" finish"));
7874 else if (op == 0xb1)
7875 {
7876 GET_OP (op2);
7877 if (op2 == 0 || (op2 & 0xf0) != 0)
7878 printf (_("[Spare]"));
7879 else
7880 {
7881 unsigned int mask = op2 & 0x0f;
7882 int first = 1;
7883 int i;
61865e30 7884
0b6ae522
DJ		 7885 printf ("pop {");
7886 for (i = 0; i < 12; i++)
7887 if (mask & (1 << i))
7888 {
7889 if (first)
7890 first = 0;
7891 else
7892 printf (", ");
7893 printf ("r%d", i);
7894 }
7895 printf ("}");
7896 }
7897 }
7898 else if (op == 0xb2)
7899 {
b115cf96 7900 unsigned char buf[9];
0b6ae522
DJ		 7901 unsigned int i, len;
7902 unsigned long offset;
61865e30 7903
b115cf96 7904 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7905 {
7906 GET_OP (buf[i]);
7907 if ((buf[i] & 0x80) == 0)
7908 break;
7909 }
4082ef84
NC		 7910 if (i == sizeof (buf))
7911 printf (_("corrupt change to vsp"));
7912 else
7913 {
7914 offset = read_uleb128 (buf, &len, buf + i + 1);
7915 assert (len == i + 1);
7916 offset = offset * 4 + 0x204;
7917 printf ("vsp = vsp + %ld", offset);
7918 }
0b6ae522 7919 }
61865e30 7920 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7921 {
61865e30
NC		 7922 unsigned int first, last;
7923
7924 GET_OP (op2);
7925 first = op2 >> 4;
7926 last = op2 & 0x0f;
7927 if (op == 0xc8)
7928 first = first + 16;
7929 printf ("pop {D%d", first);
7930 if (last)
7931 printf ("-D%d", first + last);
7932 printf ("}");
7933 }
7934 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7935 {
7936 unsigned int count = op & 0x07;
7937
7938 printf ("pop {D8");
7939 if (count)
7940 printf ("-D%d", 8 + count);
7941 printf ("}");
7942 }
7943 else if (op >= 0xc0 && op <= 0xc5)
7944 {
7945 unsigned int count = op & 0x07;
7946
7947 printf (" pop {wR10");
7948 if (count)
7949 printf ("-wR%d", 10 + count);
7950 printf ("}");
7951 }
7952 else if (op == 0xc6)
7953 {
7954 unsigned int first, last;
7955
7956 GET_OP (op2);
7957 first = op2 >> 4;
7958 last = op2 & 0x0f;
7959 printf ("pop {wR%d", first);
7960 if (last)
7961 printf ("-wR%d", first + last);
7962 printf ("}");
7963 }
7964 else if (op == 0xc7)
7965 {
7966 GET_OP (op2);
7967 if (op2 == 0 || (op2 & 0xf0) != 0)
7968 printf (_("[Spare]"));
0b6ae522
DJ		 7969 else
7970 {
61865e30
NC		 7971 unsigned int mask = op2 & 0x0f;
7972 int first = 1;
7973 int i;
7974
7975 printf ("pop {");
7976 for (i = 0; i < 4; i++)
7977 if (mask & (1 << i))
7978 {
7979 if (first)
7980 first = 0;
7981 else
7982 printf (", ");
7983 printf ("wCGR%d", i);
7984 }
7985 printf ("}");
0b6ae522
DJ		 7986 }
7987 }
61865e30
NC		 7988 else
7989 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7990 printf ("\n");
7991 }
fa197c1c
PB		 7992}
7993
7994static void
948f632f
DA		 7995decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7996 unsigned int word,
7997 unsigned int remaining,
7998 unsigned int more_words,
7999 bfd_vma data_offset,
8000 Elf_Internal_Shdr * data_sec,
8001 struct arm_section * data_arm_sec)
fa197c1c
PB		 8002{
8003 struct absaddr addr;
8004
8005 /* Decode the unwinding instructions. */
8006 while (1)
8007 {
8008 unsigned int op, op2;
8009
8010 ADVANCE;
8011 if (remaining == 0)
8012 break;
8013 remaining--;
8014 op = word >> 24;
8015 word <<= 8;
8016
9cf03b7e 8017 printf (" 0x%02x ", op);
fa197c1c
PB		 8018
8019 if ((op & 0xc0) == 0x00)
8020 {
8021 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8022 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8023 }
8024 else if ((op & 0xc0) == 0x80)
8025 {
8026 GET_OP (op2);
8027 if (op == 0x80 && op2 == 0)
8028 printf (_("Refuse to unwind"));
8029 else
8030 {
8031 unsigned int mask = ((op & 0x1f) << 8) | op2;
8032 if (op & 0x20)
8033 printf ("pop compact {");
8034 else
8035 printf ("pop {");
8036
8037 decode_tic6x_unwind_regmask (mask);
8038 printf("}");
8039 }
8040 }
8041 else if ((op & 0xf0) == 0xc0)
8042 {
8043 unsigned int reg;
8044 unsigned int nregs;
8045 unsigned int i;
8046 const char *name;
a734115a
NC		 8047 struct
8048 {
fa197c1c
PB		 8049 unsigned int offset;
8050 unsigned int reg;
8051 } regpos[16];
8052
8053 /* Scan entire instruction first so that GET_OP output is not
8054 interleaved with disassembly. */
8055 nregs = 0;
8056 for (i = 0; nregs < (op & 0xf); i++)
8057 {
8058 GET_OP (op2);
8059 reg = op2 >> 4;
8060 if (reg != 0xf)
8061 {
8062 regpos[nregs].offset = i * 2;
8063 regpos[nregs].reg = reg;
8064 nregs++;
8065 }
8066
8067 reg = op2 & 0xf;
8068 if (reg != 0xf)
8069 {
8070 regpos[nregs].offset = i * 2 + 1;
8071 regpos[nregs].reg = reg;
8072 nregs++;
8073 }
8074 }
8075
8076 printf (_("pop frame {"));
8077 reg = nregs - 1;
8078 for (i = i * 2; i > 0; i--)
8079 {
8080 if (regpos[reg].offset == i - 1)
8081 {
8082 name = tic6x_unwind_regnames[regpos[reg].reg];
8083 if (reg > 0)
8084 reg--;
8085 }
8086 else
8087 name = _("[pad]");
8088
8089 fputs (name, stdout);
8090 if (i > 1)
8091 printf (", ");
8092 }
8093
8094 printf ("}");
8095 }
8096 else if (op == 0xd0)
8097 printf (" MOV FP, SP");
8098 else if (op == 0xd1)
8099 printf (" __c6xabi_pop_rts");
8100 else if (op == 0xd2)
8101 {
8102 unsigned char buf[9];
8103 unsigned int i, len;
8104 unsigned long offset;
a734115a 8105
fa197c1c
PB		 8106 for (i = 0; i < sizeof (buf); i++)
8107 {
8108 GET_OP (buf[i]);
8109 if ((buf[i] & 0x80) == 0)
8110 break;
8111 }
0eff7165
NC		 8112 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8113 if (i == sizeof (buf))
8114 {
8115 printf ("<corrupt sp adjust>\n");
8116 warn (_("Corrupt stack pointer adjustment detected\n"));
8117 return;
8118 }
948f632f 8119
f6f0e17b 8120 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8121 assert (len == i + 1);
8122 offset = offset * 8 + 0x408;
8123 printf (_("sp = sp + %ld"), offset);
8124 }
8125 else if ((op & 0xf0) == 0xe0)
8126 {
8127 if ((op & 0x0f) == 7)
8128 printf (" RETURN");
8129 else
8130 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8131 }
8132 else
8133 {
8134 printf (_(" [unsupported opcode]"));
8135 }
8136 putchar ('\n');
8137 }
8138}
8139
8140static bfd_vma
a734115a 8141arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8142{
8143 bfd_vma offset;
8144
8145 offset = word & 0x7fffffff;
8146 if (offset & 0x40000000)
8147 offset |= ~ (bfd_vma) 0x7fffffff;
8148
8149 if (elf_header.e_machine == EM_TI_C6000)
8150 offset <<= 1;
8151
8152 return offset + where;
8153}
8154
8155static void
1b31d05e
NC		 8156decode_arm_unwind (struct arm_unw_aux_info * aux,
8157 unsigned int word,
8158 unsigned int remaining,
8159 bfd_vma data_offset,
8160 Elf_Internal_Shdr * data_sec,
8161 struct arm_section * data_arm_sec)
fa197c1c
PB		 8162{
8163 int per_index;
8164 unsigned int more_words = 0;
37e14bc3 8165 struct absaddr addr;
1b31d05e 8166 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8167
8168 if (remaining == 0)
8169 {
1b31d05e
NC		 8170 /* Fetch the first word.
8171 Note - when decoding an object file the address extracted
8172 here will always be 0. So we also pass in the sym_name
8173 parameter so that we can find the symbol associated with
8174 the personality routine. */
8175 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8176 & word, & addr, & sym_name))
fa197c1c 8177 return;
1b31d05e 8178
fa197c1c
PB		 8179 remaining = 4;
8180 }
8181
8182 if ((word & 0x80000000) == 0)
8183 {
8184 /* Expand prel31 for personality routine. */
8185 bfd_vma fn;
8186 const char *procname;
8187
a734115a 8188 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8189 printf (_(" Personality routine: "));
1b31d05e
NC		 8190 if (fn == 0
8191 && addr.section == SHN_UNDEF && addr.offset == 0
8192 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8193 {
8194 procname = aux->strtab + sym_name;
8195 print_vma (fn, PREFIX_HEX);
8196 if (procname)
8197 {
8198 fputs (" <", stdout);
8199 fputs (procname, stdout);
8200 fputc ('>', stdout);
8201 }
8202 }
8203 else
8204 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8205 fputc ('\n', stdout);
8206
8207 /* The GCC personality routines use the standard compact
8208 encoding, starting with one byte giving the number of
8209 words. */
8210 if (procname != NULL
8211 && (const_strneq (procname, "__gcc_personality_v0")
8212 || const_strneq (procname, "__gxx_personality_v0")
8213 || const_strneq (procname, "__gcj_personality_v0")
8214 || const_strneq (procname, "__gnu_objc_personality_v0")))
8215 {
8216 remaining = 0;
8217 more_words = 1;
8218 ADVANCE;
8219 if (!remaining)
8220 {
8221 printf (_(" [Truncated data]\n"));
8222 return;
8223 }
8224 more_words = word >> 24;
8225 word <<= 8;
8226 remaining--;
8227 per_index = -1;
8228 }
8229 else
8230 return;
8231 }
8232 else
8233 {
1b31d05e 8234 /* ARM EHABI Section 6.3:
0b4362b0 8235
1b31d05e 8236 An exception-handling table entry for the compact model looks like:
0b4362b0 8237
1b31d05e
NC		 8238 31 30-28 27-24 23-0
8239 -- ----- ----- ----
8240 1 0 index Data for personalityRoutine[index] */
8241
8242 if (elf_header.e_machine == EM_ARM
8243 && (word & 0x70000000))
83c257ca 8244 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8245
fa197c1c 8246 per_index = (word >> 24) & 0x7f;
1b31d05e 8247 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8248 if (per_index == 0)
8249 {
8250 more_words = 0;
8251 word <<= 8;
8252 remaining--;
8253 }
8254 else if (per_index < 3)
8255 {
8256 more_words = (word >> 16) & 0xff;
8257 word <<= 16;
8258 remaining -= 2;
8259 }
8260 }
8261
8262 switch (elf_header.e_machine)
8263 {
8264 case EM_ARM:
8265 if (per_index < 3)
8266 {
8267 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8268 data_offset, data_sec, data_arm_sec);
8269 }
8270 else
1b31d05e
NC		 8271 {
8272 warn (_("Unknown ARM compact model index encountered\n"));
8273 printf (_(" [reserved]\n"));
8274 }
fa197c1c
PB		 8275 break;
8276
8277 case EM_TI_C6000:
8278 if (per_index < 3)
8279 {
8280 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8281 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8282 }
8283 else if (per_index < 5)
8284 {
8285 if (((word >> 17) & 0x7f) == 0x7f)
8286 printf (_(" Restore stack from frame pointer\n"));
8287 else
8288 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8289 printf (_(" Registers restored: "));
8290 if (per_index == 4)
8291 printf (" (compact) ");
8292 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8293 putchar ('\n');
8294 printf (_(" Return register: %s\n"),
8295 tic6x_unwind_regnames[word & 0xf]);
8296 }
8297 else
1b31d05e 8298 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8299 break;
8300
8301 default:
74e1a04b 8302 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8303 elf_header.e_machine);
fa197c1c 8304 }
0b6ae522
DJ		 8305
8306 /* Decode the descriptors. Not implemented. */
8307}
8308
8309static void
8310dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8311{
8312 struct arm_section exidx_arm_sec, extab_arm_sec;
8313 unsigned int i, exidx_len;
948f632f 8314 unsigned long j, nfuns;
0b6ae522
DJ		 8315
8316 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8317 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8318 exidx_len = exidx_sec->sh_size / 8;
8319
948f632f
DA		 8320 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8321 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8322 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8323 aux->funtab[nfuns++] = aux->symtab[j];
8324 aux->nfuns = nfuns;
8325 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8326
0b6ae522
DJ		 8327 for (i = 0; i < exidx_len; i++)
8328 {
8329 unsigned int exidx_fn, exidx_entry;
8330 struct absaddr fn_addr, entry_addr;
8331 bfd_vma fn;
8332
8333 fputc ('\n', stdout);
8334
1b31d05e
NC		 8335 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8336 8 * i, & exidx_fn, & fn_addr, NULL)
8337 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8338 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8339 {
948f632f 8340 free (aux->funtab);
1b31d05e
NC		 8341 arm_free_section (& exidx_arm_sec);
8342 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8343 return;
8344 }
8345
83c257ca
NC		 8346 /* ARM EHABI, Section 5:
8347 An index table entry consists of 2 words.
8348 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8349 if (exidx_fn & 0x80000000)
8350 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8351
a734115a 8352 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8353
a734115a 8354 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8355 fputs (": ", stdout);
8356
8357 if (exidx_entry == 1)
8358 {
8359 print_vma (exidx_entry, PREFIX_HEX);
8360 fputs (" [cantunwind]\n", stdout);
8361 }
8362 else if (exidx_entry & 0x80000000)
8363 {
8364 print_vma (exidx_entry, PREFIX_HEX);
8365 fputc ('\n', stdout);
8366 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8367 }
8368 else
8369 {
8f73510c 8370 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8371 Elf_Internal_Shdr *table_sec;
8372
8373 fputs ("@", stdout);
a734115a 8374 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8375 print_vma (table, PREFIX_HEX);
8376 printf ("\n");
8377
8378 /* Locate the matching .ARM.extab. */
8379 if (entry_addr.section != SHN_UNDEF
8380 && entry_addr.section < elf_header.e_shnum)
8381 {
8382 table_sec = section_headers + entry_addr.section;
8383 table_offset = entry_addr.offset;
1a915552
NC		 8384 /* PR 18879 */
8385 if (table_offset > table_sec->sh_size
8386 || ((bfd_signed_vma) table_offset) < 0)
8387 {
8388 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8389 (unsigned long) table_offset,
8390 printable_section_name (table_sec));
8391 continue;
8392 }
0b6ae522
DJ		 8393 }
8394 else
8395 {
8396 table_sec = find_section_by_address (table);
8397 if (table_sec != NULL)
8398 table_offset = table - table_sec->sh_addr;
8399 }
8400 if (table_sec == NULL)
8401 {
8402 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8403 (unsigned long) table);
8404 continue;
8405 }
8406 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8407 &extab_arm_sec);
8408 }
8409 }
8410
8411 printf ("\n");
8412
948f632f 8413 free (aux->funtab);
0b6ae522
DJ		 8414 arm_free_section (&exidx_arm_sec);
8415 arm_free_section (&extab_arm_sec);
8416}
8417
fa197c1c 8418/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8419
8420static void
0b6ae522
DJ		 8421arm_process_unwind (FILE *file)
8422{
8423 struct arm_unw_aux_info aux;
8424 Elf_Internal_Shdr *unwsec = NULL;
8425 Elf_Internal_Shdr *strsec;
8426 Elf_Internal_Shdr *sec;
8427 unsigned long i;
fa197c1c 8428 unsigned int sec_type;
0b6ae522 8429
fa197c1c
PB		 8430 switch (elf_header.e_machine)
8431 {
8432 case EM_ARM:
8433 sec_type = SHT_ARM_EXIDX;
8434 break;
8435
8436 case EM_TI_C6000:
8437 sec_type = SHT_C6000_UNWIND;
8438 break;
8439
0b4362b0 8440 default:
74e1a04b 8441 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8442 elf_header.e_machine);
8443 return;
fa197c1c
PB		 8444 }
8445
0b6ae522 8446 if (string_table == NULL)
1b31d05e
NC		 8447 return;
8448
8449 memset (& aux, 0, sizeof (aux));
8450 aux.file = file;
0b6ae522
DJ		 8451
8452 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8453 {
8454 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8455 {
ba5cdace 8456 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8457
8458 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8459
8460 /* PR binutils/17531 file: 011-12666-0.004. */
8461 if (aux.strtab != NULL)
8462 {
4082ef84 8463 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8464 free (aux.strtab);
8465 }
0b6ae522
DJ		 8466 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8467 1, strsec->sh_size, _("string table"));
8468 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8469 }
fa197c1c 8470 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8471 unwsec = sec;
8472 }
8473
1b31d05e 8474 if (unwsec == NULL)
0b6ae522 8475 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8476 else
8477 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8478 {
8479 if (sec->sh_type == sec_type)
8480 {
8481 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8482 printable_section_name (sec),
1b31d05e
NC		 8483 (unsigned long) sec->sh_offset,
8484 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8485
1b31d05e
NC		 8486 dump_arm_unwind (&aux, sec);
8487 }
8488 }
0b6ae522
DJ		 8489
8490 if (aux.symtab)
8491 free (aux.symtab);
8492 if (aux.strtab)
8493 free ((char *) aux.strtab);
0b6ae522
DJ		 8494}
8495
1b31d05e 8496static void
2cf0635d 8497process_unwind (FILE * file)
57346661 8498{
2cf0635d
NC		 8499 struct unwind_handler
8500 {
57346661 8501 int machtype;
1b31d05e 8502 void (* handler)(FILE *);
2cf0635d
NC		 8503 } handlers[] =
8504 {
0b6ae522 8505 { EM_ARM, arm_process_unwind },
57346661
AM		 8506 { EM_IA_64, ia64_process_unwind },
8507 { EM_PARISC, hppa_process_unwind },
fa197c1c 8508 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8509 { 0, 0 }
8510 };
8511 int i;
8512
8513 if (!do_unwind)
1b31d05e 8514 return;
57346661
AM		 8515
8516 for (i = 0; handlers[i].handler != NULL; i++)
8517 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8518 {
8519 handlers[i].handler (file);
8520 return;
8521 }
57346661 8522
1b31d05e
NC		 8523 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8524 get_machine_name (elf_header.e_machine));
57346661
AM		 8525}
8526
252b5132 8527static void
2cf0635d 8528dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8529{
8530 switch (entry->d_tag)
8531 {
8532 case DT_MIPS_FLAGS:
8533 if (entry->d_un.d_val == 0)
4b68bca3 8534 printf (_("NONE"));
252b5132
RH		 8535 else
8536 {
8537 static const char * opts[] =
8538 {
8539 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8540 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8541 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8542 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8543 "RLD_ORDER_SAFE"
8544 };
8545 unsigned int cnt;
8546 int first = 1;
2b692964 8547
60bca95a 8548 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8549 if (entry->d_un.d_val & (1 << cnt))
8550 {
8551 printf ("%s%s", first ? "" : " ", opts[cnt]);
8552 first = 0;
8553 }
252b5132
RH		 8554 }
8555 break;
103f02d3 8556
252b5132 8557 case DT_MIPS_IVERSION:
d79b3d50 8558 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8559 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8560 else
76ca31c0
NC		 8561 {
8562 char buf[40];
8563 sprintf_vma (buf, entry->d_un.d_ptr);
8564 /* Note: coded this way so that there is a single string for translation. */
8565 printf (_("<corrupt: %s>"), buf);
8566 }
252b5132 8567 break;
103f02d3 8568
252b5132
RH		 8569 case DT_MIPS_TIME_STAMP:
8570 {
8571 char timebuf[20];
2cf0635d 8572 struct tm * tmp;
91d6fa6a 8573 time_t atime = entry->d_un.d_val;
82b1b41b 8574
91d6fa6a 8575 tmp = gmtime (&atime);
82b1b41b
NC		 8576 /* PR 17531: file: 6accc532. */
8577 if (tmp == NULL)
8578 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8579 else
8580 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8581 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8582 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8583 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8584 }
8585 break;
103f02d3 8586
252b5132
RH		 8587 case DT_MIPS_RLD_VERSION:
8588 case DT_MIPS_LOCAL_GOTNO:
8589 case DT_MIPS_CONFLICTNO:
8590 case DT_MIPS_LIBLISTNO:
8591 case DT_MIPS_SYMTABNO:
8592 case DT_MIPS_UNREFEXTNO:
8593 case DT_MIPS_HIPAGENO:
8594 case DT_MIPS_DELTA_CLASS_NO:
8595 case DT_MIPS_DELTA_INSTANCE_NO:
8596 case DT_MIPS_DELTA_RELOC_NO:
8597 case DT_MIPS_DELTA_SYM_NO:
8598 case DT_MIPS_DELTA_CLASSSYM_NO:
8599 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8600 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8601 break;
103f02d3
UD		 8602
8603 default:
4b68bca3 8604 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8605 }
4b68bca3 8606 putchar ('\n');
103f02d3
UD		 8607}
8608
103f02d3 8609static void
2cf0635d 8610dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8611{
8612 switch (entry->d_tag)
8613 {
8614 case DT_HP_DLD_FLAGS:
8615 {
8616 static struct
8617 {
8618 long int bit;
2cf0635d 8619 const char * str;
5e220199
NC		 8620 }
8621 flags[] =
8622 {
8623 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8624 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8625 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8626 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8627 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8628 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8629 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8630 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8631 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8632 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8633 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8634 { DT_HP_GST, "HP_GST" },
8635 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8636 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8637 { DT_HP_NODELETE, "HP_NODELETE" },
8638 { DT_HP_GROUP, "HP_GROUP" },
8639 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8640 };
103f02d3 8641 int first = 1;
5e220199 8642 size_t cnt;
f7a99963 8643 bfd_vma val = entry->d_un.d_val;
103f02d3 8644
60bca95a 8645 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8646 if (val & flags[cnt].bit)
30800947
NC		 8647 {
8648 if (! first)
8649 putchar (' ');
8650 fputs (flags[cnt].str, stdout);
8651 first = 0;
8652 val ^= flags[cnt].bit;
8653 }
76da6bbe 8654
103f02d3 8655 if (val != 0 || first)
f7a99963
NC		 8656 {
8657 if (! first)
8658 putchar (' ');
8659 print_vma (val, HEX);
8660 }
103f02d3
UD		 8661 }
8662 break;
76da6bbe 8663
252b5132 8664 default:
f7a99963
NC		 8665 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8666 break;
252b5132 8667 }
35b1837e 8668 putchar ('\n');
252b5132
RH		 8669}
8670
28f997cf
TG		 8671#ifdef BFD64
8672
8673/* VMS vs Unix time offset and factor. */
8674
8675#define VMS_EPOCH_OFFSET 35067168000000000LL
8676#define VMS_GRANULARITY_FACTOR 10000000
8677
8678/* Display a VMS time in a human readable format. */
8679
8680static void
8681print_vms_time (bfd_int64_t vmstime)
8682{
8683 struct tm *tm;
8684 time_t unxtime;
8685
8686 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8687 tm = gmtime (&unxtime);
8688 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8689 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8690 tm->tm_hour, tm->tm_min, tm->tm_sec);
8691}
8692#endif /* BFD64 */
8693
ecc51f48 8694static void
2cf0635d 8695dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8696{
8697 switch (entry->d_tag)
8698 {
0de14b54 8699 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8700 /* First 3 slots reserved. */
ecc51f48
NC		 8701 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8702 printf (" -- ");
8703 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8704 break;
8705
28f997cf
TG		 8706 case DT_IA_64_VMS_LINKTIME:
8707#ifdef BFD64
8708 print_vms_time (entry->d_un.d_val);
8709#endif
8710 break;
8711
8712 case DT_IA_64_VMS_LNKFLAGS:
8713 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8714 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8715 printf (" CALL_DEBUG");
8716 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8717 printf (" NOP0BUFS");
8718 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8719 printf (" P0IMAGE");
8720 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8721 printf (" MKTHREADS");
8722 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8723 printf (" UPCALLS");
8724 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8725 printf (" IMGSTA");
8726 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8727 printf (" INITIALIZE");
8728 if (entry->d_un.d_val & VMS_LF_MAIN)
8729 printf (" MAIN");
8730 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8731 printf (" EXE_INIT");
8732 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8733 printf (" TBK_IN_IMG");
8734 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8735 printf (" DBG_IN_IMG");
8736 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8737 printf (" TBK_IN_DSF");
8738 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8739 printf (" DBG_IN_DSF");
8740 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8741 printf (" SIGNATURES");
8742 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8743 printf (" REL_SEG_OFF");
8744 break;
8745
bdf4d63a
JJ		 8746 default:
8747 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8748 break;
ecc51f48 8749 }
bdf4d63a 8750 putchar ('\n');
ecc51f48
NC		 8751}
8752
252b5132 8753static int
2cf0635d 8754get_32bit_dynamic_section (FILE * file)
252b5132 8755{
2cf0635d
NC		 8756 Elf32_External_Dyn * edyn;
8757 Elf32_External_Dyn * ext;
8758 Elf_Internal_Dyn * entry;
103f02d3 8759
3f5e193b
NC		 8760 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8761 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8762 if (!edyn)
8763 return 0;
103f02d3 8764
071436c6
NC		 8765 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8766 might not have the luxury of section headers. Look for the DT_NULL
8767 terminator to determine the number of entries. */
ba2685cc 8768 for (ext = edyn, dynamic_nent = 0;
53c3012c 8769 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8770 ext++)
8771 {
8772 dynamic_nent++;
8773 if (BYTE_GET (ext->d_tag) == DT_NULL)
8774 break;
8775 }
252b5132 8776
3f5e193b
NC		 8777 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8778 sizeof (* entry));
b2d38a17 8779 if (dynamic_section == NULL)
252b5132 8780 {
8b73c356
NC		 8781 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8782 (unsigned long) dynamic_nent);
9ea033b2
NC		 8783 free (edyn);
8784 return 0;
8785 }
252b5132 8786
fb514b26 8787 for (ext = edyn, entry = dynamic_section;
ba2685cc 8788 entry < dynamic_section + dynamic_nent;
fb514b26 8789 ext++, entry++)
9ea033b2 8790 {
fb514b26
AM		 8791 entry->d_tag = BYTE_GET (ext->d_tag);
8792 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8793 }
8794
9ea033b2
NC		 8795 free (edyn);
8796
8797 return 1;
8798}
8799
8800static int
2cf0635d 8801get_64bit_dynamic_section (FILE * file)
9ea033b2 8802{
2cf0635d
NC		 8803 Elf64_External_Dyn * edyn;
8804 Elf64_External_Dyn * ext;
8805 Elf_Internal_Dyn * entry;
103f02d3 8806
071436c6 8807 /* Read in the data. */
3f5e193b
NC		 8808 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8809 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8810 if (!edyn)
8811 return 0;
103f02d3 8812
071436c6
NC		 8813 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8814 might not have the luxury of section headers. Look for the DT_NULL
8815 terminator to determine the number of entries. */
ba2685cc 8816 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8817 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8818 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8819 ext++)
8820 {
8821 dynamic_nent++;
66543521 8822 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8823 break;
8824 }
252b5132 8825
3f5e193b
NC		 8826 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8827 sizeof (* entry));
b2d38a17 8828 if (dynamic_section == NULL)
252b5132 8829 {
8b73c356
NC		 8830 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8831 (unsigned long) dynamic_nent);
252b5132
RH		 8832 free (edyn);
8833 return 0;
8834 }
8835
071436c6 8836 /* Convert from external to internal formats. */
fb514b26 8837 for (ext = edyn, entry = dynamic_section;
ba2685cc 8838 entry < dynamic_section + dynamic_nent;
fb514b26 8839 ext++, entry++)
252b5132 8840 {
66543521
AM		 8841 entry->d_tag = BYTE_GET (ext->d_tag);
8842 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8843 }
8844
8845 free (edyn);
8846
9ea033b2
NC		 8847 return 1;
8848}
8849
e9e44622
JJ		 8850static void
8851print_dynamic_flags (bfd_vma flags)
d1133906 8852{
e9e44622 8853 int first = 1;
13ae64f3 8854
d1133906
NC		 8855 while (flags)
8856 {
8857 bfd_vma flag;
8858
8859 flag = flags & - flags;
8860 flags &= ~ flag;
8861
e9e44622
JJ		 8862 if (first)
8863 first = 0;
8864 else
8865 putc (' ', stdout);
13ae64f3 8866
d1133906
NC		 8867 switch (flag)
8868 {
e9e44622
JJ		 8869 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8870 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8871 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8872 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8873 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8874 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8875 }
8876 }
e9e44622 8877 puts ("");
d1133906
NC		 8878}
8879
b2d38a17
NC		 8880/* Parse and display the contents of the dynamic section. */
8881
9ea033b2 8882static int
2cf0635d 8883process_dynamic_section (FILE * file)
9ea033b2 8884{
2cf0635d 8885 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8886
8887 if (dynamic_size == 0)
8888 {
8889 if (do_dynamic)
b2d38a17 8890 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8891
8892 return 1;
8893 }
8894
8895 if (is_32bit_elf)
8896 {
b2d38a17 8897 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8898 return 0;
8899 }
b2d38a17 8900 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8901 return 0;
8902
252b5132
RH		 8903 /* Find the appropriate symbol table. */
8904 if (dynamic_symbols == NULL)
8905 {
86dba8ee
AM		 8906 for (entry = dynamic_section;
8907 entry < dynamic_section + dynamic_nent;
8908 ++entry)
252b5132 8909 {
c8286bd1 8910 Elf_Internal_Shdr section;
252b5132
RH		 8911
8912 if (entry->d_tag != DT_SYMTAB)
8913 continue;
8914
8915 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8916
8917 /* Since we do not know how big the symbol table is,
8918 we default to reading in the entire file (!) and
8919 processing that. This is overkill, I know, but it
e3c8793a 8920 should work. */
d93f0186 8921 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8922
fb52b2f4
NC		 8923 if (archive_file_offset != 0)
8924 section.sh_size = archive_file_size - section.sh_offset;
8925 else
8926 {
8927 if (fseek (file, 0, SEEK_END))
591a748a 8928 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8929
8930 section.sh_size = ftell (file) - section.sh_offset;
8931 }
252b5132 8932
9ea033b2 8933 if (is_32bit_elf)
9ad5cbcf 8934 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8935 else
9ad5cbcf 8936 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8937 section.sh_name = string_table_length;
252b5132 8938
ba5cdace 8939 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8940 if (num_dynamic_syms < 1)
252b5132
RH		 8941 {
8942 error (_("Unable to determine the number of symbols to load\n"));
8943 continue;
8944 }
252b5132
RH		 8945 }
8946 }
8947
8948 /* Similarly find a string table. */
8949 if (dynamic_strings == NULL)
8950 {
86dba8ee
AM		 8951 for (entry = dynamic_section;
8952 entry < dynamic_section + dynamic_nent;
8953 ++entry)
252b5132
RH		 8954 {
8955 unsigned long offset;
b34976b6 8956 long str_tab_len;
252b5132
RH		 8957
8958 if (entry->d_tag != DT_STRTAB)
8959 continue;
8960
8961 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8962
8963 /* Since we do not know how big the string table is,
8964 we default to reading in the entire file (!) and
8965 processing that. This is overkill, I know, but it
e3c8793a 8966 should work. */
252b5132 8967
d93f0186 8968 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8969
8970 if (archive_file_offset != 0)
8971 str_tab_len = archive_file_size - offset;
8972 else
8973 {
8974 if (fseek (file, 0, SEEK_END))
8975 error (_("Unable to seek to end of file\n"));
8976 str_tab_len = ftell (file) - offset;
8977 }
252b5132
RH		 8978
8979 if (str_tab_len < 1)
8980 {
8981 error
8982 (_("Unable to determine the length of the dynamic string table\n"));
8983 continue;
8984 }
8985
3f5e193b
NC		 8986 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8987 str_tab_len,
8988 _("dynamic string table"));
59245841 8989 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8990 break;
8991 }
8992 }
8993
8994 /* And find the syminfo section if available. */
8995 if (dynamic_syminfo == NULL)
8996 {
3e8bba36 8997 unsigned long syminsz = 0;
252b5132 8998
86dba8ee
AM		 8999 for (entry = dynamic_section;
9000 entry < dynamic_section + dynamic_nent;
9001 ++entry)
252b5132
RH		 9002 {
9003 if (entry->d_tag == DT_SYMINENT)
9004 {
9005 /* Note: these braces are necessary to avoid a syntax
9006 error from the SunOS4 C compiler. */
049b0c3a
NC		 9007 /* PR binutils/17531: A corrupt file can trigger this test.
9008 So do not use an assert, instead generate an error message. */
9009 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9010 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9011 (int) entry->d_un.d_val);
252b5132
RH		 9012 }
9013 else if (entry->d_tag == DT_SYMINSZ)
9014 syminsz = entry->d_un.d_val;
9015 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9016 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9017 syminsz);
252b5132
RH		 9018 }
9019
9020 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9021 {
2cf0635d
NC		 9022 Elf_External_Syminfo * extsyminfo;
9023 Elf_External_Syminfo * extsym;
9024 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9025
9026 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9027 extsyminfo = (Elf_External_Syminfo *)
9028 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9029 _("symbol information"));
a6e9f9df
AM		 9030 if (!extsyminfo)
9031 return 0;
252b5132 9032
3f5e193b 9033 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9034 if (dynamic_syminfo == NULL)
9035 {
8b73c356
NC		 9036 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9037 (unsigned long) syminsz);
252b5132
RH		 9038 return 0;
9039 }
9040
9041 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9042 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9043 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9044 ++syminfo, ++extsym)
252b5132 9045 {
86dba8ee
AM		 9046 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9047 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9048 }
9049
9050 free (extsyminfo);
9051 }
9052 }
9053
9054 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9055 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9056 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9057 if (do_dynamic)
9058 printf (_(" Tag Type Name/Value\n"));
9059
86dba8ee
AM		 9060 for (entry = dynamic_section;
9061 entry < dynamic_section + dynamic_nent;
9062 entry++)
252b5132
RH		 9063 {
9064 if (do_dynamic)
f7a99963 9065 {
2cf0635d 9066 const char * dtype;
e699b9ff 9067
f7a99963
NC		 9068 putchar (' ');
9069 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9070 dtype = get_dynamic_type (entry->d_tag);
9071 printf (" (%s)%*s", dtype,
9072 ((is_32bit_elf ? 27 : 19)
9073 - (int) strlen (dtype)),
f7a99963
NC		 9074 " ");
9075 }
252b5132
RH		 9076
9077 switch (entry->d_tag)
9078 {
d1133906
NC		 9079 case DT_FLAGS:
9080 if (do_dynamic)
e9e44622 9081 print_dynamic_flags (entry->d_un.d_val);
d1133906 9082 break;
76da6bbe 9083
252b5132
RH		 9084 case DT_AUXILIARY:
9085 case DT_FILTER:
019148e4
L		 9086 case DT_CONFIG:
9087 case DT_DEPAUDIT:
9088 case DT_AUDIT:
252b5132
RH		 9089 if (do_dynamic)
9090 {
019148e4 9091 switch (entry->d_tag)
b34976b6 9092 {
019148e4
L		 9093 case DT_AUXILIARY:
9094 printf (_("Auxiliary library"));
9095 break;
9096
9097 case DT_FILTER:
9098 printf (_("Filter library"));
9099 break;
9100
b34976b6 9101 case DT_CONFIG:
019148e4
L		 9102 printf (_("Configuration file"));
9103 break;
9104
9105 case DT_DEPAUDIT:
9106 printf (_("Dependency audit library"));
9107 break;
9108
9109 case DT_AUDIT:
9110 printf (_("Audit library"));
9111 break;
9112 }
252b5132 9113
d79b3d50
NC		 9114 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9115 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9116 else
f7a99963
NC		 9117 {
9118 printf (": ");
9119 print_vma (entry->d_un.d_val, PREFIX_HEX);
9120 putchar ('\n');
9121 }
252b5132
RH		 9122 }
9123 break;
9124
dcefbbbd 9125 case DT_FEATURE:
252b5132
RH		 9126 if (do_dynamic)
9127 {
9128 printf (_("Flags:"));
86f55779 9129
252b5132
RH		 9130 if (entry->d_un.d_val == 0)
9131 printf (_(" None\n"));
9132 else
9133 {
9134 unsigned long int val = entry->d_un.d_val;
86f55779 9135
252b5132
RH		 9136 if (val & DTF_1_PARINIT)
9137 {
9138 printf (" PARINIT");
9139 val ^= DTF_1_PARINIT;
9140 }
dcefbbbd
L		 9141 if (val & DTF_1_CONFEXP)
9142 {
9143 printf (" CONFEXP");
9144 val ^= DTF_1_CONFEXP;
9145 }
252b5132
RH		 9146 if (val != 0)
9147 printf (" %lx", val);
9148 puts ("");
9149 }
9150 }
9151 break;
9152
9153 case DT_POSFLAG_1:
9154 if (do_dynamic)
9155 {
9156 printf (_("Flags:"));
86f55779 9157
252b5132
RH		 9158 if (entry->d_un.d_val == 0)
9159 printf (_(" None\n"));
9160 else
9161 {
9162 unsigned long int val = entry->d_un.d_val;
86f55779 9163
252b5132
RH		 9164 if (val & DF_P1_LAZYLOAD)
9165 {
9166 printf (" LAZYLOAD");
9167 val ^= DF_P1_LAZYLOAD;
9168 }
9169 if (val & DF_P1_GROUPPERM)
9170 {
9171 printf (" GROUPPERM");
9172 val ^= DF_P1_GROUPPERM;
9173 }
9174 if (val != 0)
9175 printf (" %lx", val);
9176 puts ("");
9177 }
9178 }
9179 break;
9180
9181 case DT_FLAGS_1:
9182 if (do_dynamic)
9183 {
9184 printf (_("Flags:"));
9185 if (entry->d_un.d_val == 0)
9186 printf (_(" None\n"));
9187 else
9188 {
9189 unsigned long int val = entry->d_un.d_val;
86f55779 9190
252b5132
RH		 9191 if (val & DF_1_NOW)
9192 {
9193 printf (" NOW");
9194 val ^= DF_1_NOW;
9195 }
9196 if (val & DF_1_GLOBAL)
9197 {
9198 printf (" GLOBAL");
9199 val ^= DF_1_GLOBAL;
9200 }
9201 if (val & DF_1_GROUP)
9202 {
9203 printf (" GROUP");
9204 val ^= DF_1_GROUP;
9205 }
9206 if (val & DF_1_NODELETE)
9207 {
9208 printf (" NODELETE");
9209 val ^= DF_1_NODELETE;
9210 }
9211 if (val & DF_1_LOADFLTR)
9212 {
9213 printf (" LOADFLTR");
9214 val ^= DF_1_LOADFLTR;
9215 }
9216 if (val & DF_1_INITFIRST)
9217 {
9218 printf (" INITFIRST");
9219 val ^= DF_1_INITFIRST;
9220 }
9221 if (val & DF_1_NOOPEN)
9222 {
9223 printf (" NOOPEN");
9224 val ^= DF_1_NOOPEN;
9225 }
9226 if (val & DF_1_ORIGIN)
9227 {
9228 printf (" ORIGIN");
9229 val ^= DF_1_ORIGIN;
9230 }
9231 if (val & DF_1_DIRECT)
9232 {
9233 printf (" DIRECT");
9234 val ^= DF_1_DIRECT;
9235 }
9236 if (val & DF_1_TRANS)
9237 {
9238 printf (" TRANS");
9239 val ^= DF_1_TRANS;
9240 }
9241 if (val & DF_1_INTERPOSE)
9242 {
9243 printf (" INTERPOSE");
9244 val ^= DF_1_INTERPOSE;
9245 }
f7db6139 9246 if (val & DF_1_NODEFLIB)
dcefbbbd 9247 {
f7db6139
L		 9248 printf (" NODEFLIB");
9249 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9250 }
9251 if (val & DF_1_NODUMP)
9252 {
9253 printf (" NODUMP");
9254 val ^= DF_1_NODUMP;
9255 }
34b60028 9256 if (val & DF_1_CONFALT)
dcefbbbd 9257 {
34b60028
L		 9258 printf (" CONFALT");
9259 val ^= DF_1_CONFALT;
9260 }
9261 if (val & DF_1_ENDFILTEE)
9262 {
9263 printf (" ENDFILTEE");
9264 val ^= DF_1_ENDFILTEE;
9265 }
9266 if (val & DF_1_DISPRELDNE)
9267 {
9268 printf (" DISPRELDNE");
9269 val ^= DF_1_DISPRELDNE;
9270 }
9271 if (val & DF_1_DISPRELPND)
9272 {
9273 printf (" DISPRELPND");
9274 val ^= DF_1_DISPRELPND;
9275 }
9276 if (val & DF_1_NODIRECT)
9277 {
9278 printf (" NODIRECT");
9279 val ^= DF_1_NODIRECT;
9280 }
9281 if (val & DF_1_IGNMULDEF)
9282 {
9283 printf (" IGNMULDEF");
9284 val ^= DF_1_IGNMULDEF;
9285 }
9286 if (val & DF_1_NOKSYMS)
9287 {
9288 printf (" NOKSYMS");
9289 val ^= DF_1_NOKSYMS;
9290 }
9291 if (val & DF_1_NOHDR)
9292 {
9293 printf (" NOHDR");
9294 val ^= DF_1_NOHDR;
9295 }
9296 if (val & DF_1_EDITED)
9297 {
9298 printf (" EDITED");
9299 val ^= DF_1_EDITED;
9300 }
9301 if (val & DF_1_NORELOC)
9302 {
9303 printf (" NORELOC");
9304 val ^= DF_1_NORELOC;
9305 }
9306 if (val & DF_1_SYMINTPOSE)
9307 {
9308 printf (" SYMINTPOSE");
9309 val ^= DF_1_SYMINTPOSE;
9310 }
9311 if (val & DF_1_GLOBAUDIT)
9312 {
9313 printf (" GLOBAUDIT");
9314 val ^= DF_1_GLOBAUDIT;
9315 }
9316 if (val & DF_1_SINGLETON)
9317 {
9318 printf (" SINGLETON");
9319 val ^= DF_1_SINGLETON;
dcefbbbd 9320 }
5c383f02
RO		 9321 if (val & DF_1_STUB)
9322 {
9323 printf (" STUB");
9324 val ^= DF_1_STUB;
9325 }
9326 if (val & DF_1_PIE)
9327 {
9328 printf (" PIE");
9329 val ^= DF_1_PIE;
9330 }
252b5132
RH		 9331 if (val != 0)
9332 printf (" %lx", val);
9333 puts ("");
9334 }
9335 }
9336 break;
9337
9338 case DT_PLTREL:
566b0d53 9339 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9340 if (do_dynamic)
9341 puts (get_dynamic_type (entry->d_un.d_val));
9342 break;
9343
9344 case DT_NULL :
9345 case DT_NEEDED :
9346 case DT_PLTGOT :
9347 case DT_HASH :
9348 case DT_STRTAB :
9349 case DT_SYMTAB :
9350 case DT_RELA :
9351 case DT_INIT :
9352 case DT_FINI :
9353 case DT_SONAME :
9354 case DT_RPATH :
9355 case DT_SYMBOLIC:
9356 case DT_REL :
9357 case DT_DEBUG :
9358 case DT_TEXTREL :
9359 case DT_JMPREL :
019148e4 9360 case DT_RUNPATH :
252b5132
RH		 9361 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9362
9363 if (do_dynamic)
9364 {
2cf0635d 9365 char * name;
252b5132 9366
d79b3d50
NC		 9367 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9368 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9369 else
d79b3d50 9370 name = NULL;
252b5132
RH		 9371
9372 if (name)
9373 {
9374 switch (entry->d_tag)
9375 {
9376 case DT_NEEDED:
9377 printf (_("Shared library: [%s]"), name);
9378
18bd398b 9379 if (streq (name, program_interpreter))
f7a99963 9380 printf (_(" program interpreter"));
252b5132
RH		 9381 break;
9382
9383 case DT_SONAME:
f7a99963 9384 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9385 break;
9386
9387 case DT_RPATH:
f7a99963 9388 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9389 break;
9390
019148e4
L		 9391 case DT_RUNPATH:
9392 printf (_("Library runpath: [%s]"), name);
9393 break;
9394
252b5132 9395 default:
f7a99963
NC		 9396 print_vma (entry->d_un.d_val, PREFIX_HEX);
9397 break;
252b5132
RH		 9398 }
9399 }
9400 else
f7a99963
NC		 9401 print_vma (entry->d_un.d_val, PREFIX_HEX);
9402
9403 putchar ('\n');
252b5132
RH		 9404 }
9405 break;
9406
9407 case DT_PLTRELSZ:
9408 case DT_RELASZ :
9409 case DT_STRSZ :
9410 case DT_RELSZ :
9411 case DT_RELAENT :
9412 case DT_SYMENT :
9413 case DT_RELENT :
566b0d53 9414 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9415 case DT_PLTPADSZ:
9416 case DT_MOVEENT :
9417 case DT_MOVESZ :
9418 case DT_INIT_ARRAYSZ:
9419 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9420 case DT_GNU_CONFLICTSZ:
9421 case DT_GNU_LIBLISTSZ:
252b5132 9422 if (do_dynamic)
f7a99963
NC		 9423 {
9424 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9425 printf (_(" (bytes)\n"));
f7a99963 9426 }
252b5132
RH		 9427 break;
9428
9429 case DT_VERDEFNUM:
9430 case DT_VERNEEDNUM:
9431 case DT_RELACOUNT:
9432 case DT_RELCOUNT:
9433 if (do_dynamic)
f7a99963
NC		 9434 {
9435 print_vma (entry->d_un.d_val, UNSIGNED);
9436 putchar ('\n');
9437 }
252b5132
RH		 9438 break;
9439
9440 case DT_SYMINSZ:
9441 case DT_SYMINENT:
9442 case DT_SYMINFO:
9443 case DT_USED:
9444 case DT_INIT_ARRAY:
9445 case DT_FINI_ARRAY:
9446 if (do_dynamic)
9447 {
d79b3d50
NC		 9448 if (entry->d_tag == DT_USED
9449 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9450 {
2cf0635d 9451 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9452
b34976b6 9453 if (*name)
252b5132
RH		 9454 {
9455 printf (_("Not needed object: [%s]\n"), name);
9456 break;
9457 }
9458 }
103f02d3 9459
f7a99963
NC		 9460 print_vma (entry->d_un.d_val, PREFIX_HEX);
9461 putchar ('\n');
252b5132
RH		 9462 }
9463 break;
9464
9465 case DT_BIND_NOW:
9466 /* The value of this entry is ignored. */
35b1837e
AM		 9467 if (do_dynamic)
9468 putchar ('\n');
252b5132 9469 break;
103f02d3 9470
047b2264
JJ		 9471 case DT_GNU_PRELINKED:
9472 if (do_dynamic)
9473 {
2cf0635d 9474 struct tm * tmp;
91d6fa6a 9475 time_t atime = entry->d_un.d_val;
047b2264 9476
91d6fa6a 9477 tmp = gmtime (&atime);
071436c6
NC		 9478 /* PR 17533 file: 041-1244816-0.004. */
9479 if (tmp == NULL)
5a2cbcf4
L		 9480 printf (_("<corrupt time val: %lx"),
9481 (unsigned long) atime);
071436c6
NC		 9482 else
9483 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9484 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9485 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9486
9487 }
9488 break;
9489
fdc90cb4
JJ		 9490 case DT_GNU_HASH:
9491 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9492 if (do_dynamic)
9493 {
9494 print_vma (entry->d_un.d_val, PREFIX_HEX);
9495 putchar ('\n');
9496 }
9497 break;
9498
252b5132
RH		 9499 default:
9500 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9501 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9502 entry->d_un.d_val;
9503
9504 if (do_dynamic)
9505 {
9506 switch (elf_header.e_machine)
9507 {
9508 case EM_MIPS:
4fe85591 9509 case EM_MIPS_RS3_LE:
b2d38a17 9510 dynamic_section_mips_val (entry);
252b5132 9511 break;
103f02d3 9512 case EM_PARISC:
b2d38a17 9513 dynamic_section_parisc_val (entry);
103f02d3 9514 break;
ecc51f48 9515 case EM_IA_64:
b2d38a17 9516 dynamic_section_ia64_val (entry);
ecc51f48 9517 break;
252b5132 9518 default:
f7a99963
NC		 9519 print_vma (entry->d_un.d_val, PREFIX_HEX);
9520 putchar ('\n');
252b5132
RH		 9521 }
9522 }
9523 break;
9524 }
9525 }
9526
9527 return 1;
9528}
9529
9530static char *
d3ba0551 9531get_ver_flags (unsigned int flags)
252b5132 9532{
b34976b6 9533 static char buff[32];
252b5132
RH		 9534
9535 buff[0] = 0;
9536
9537 if (flags == 0)
9538 return _("none");
9539
9540 if (flags & VER_FLG_BASE)
9541 strcat (buff, "BASE ");
9542
9543 if (flags & VER_FLG_WEAK)
9544 {
9545 if (flags & VER_FLG_BASE)
9546 strcat (buff, "| ");
9547
9548 strcat (buff, "WEAK ");
9549 }
9550
44ec90b9
RO		 9551 if (flags & VER_FLG_INFO)
9552 {
9553 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9554 strcat (buff, "| ");
9555
9556 strcat (buff, "INFO ");
9557 }
9558
9559 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9560 strcat (buff, _("| <unknown>"));
252b5132
RH		 9561
9562 return buff;
9563}
9564
9565/* Display the contents of the version sections. */
98fb390a 9566
252b5132 9567static int
2cf0635d 9568process_version_sections (FILE * file)
252b5132 9569{
2cf0635d 9570 Elf_Internal_Shdr * section;
b34976b6
AM		 9571 unsigned i;
9572 int found = 0;
252b5132
RH		 9573
9574 if (! do_version)
9575 return 1;
9576
9577 for (i = 0, section = section_headers;
9578 i < elf_header.e_shnum;
b34976b6 9579 i++, section++)
252b5132
RH		 9580 {
9581 switch (section->sh_type)
9582 {
9583 case SHT_GNU_verdef:
9584 {
2cf0635d 9585 Elf_External_Verdef * edefs;
b34976b6
AM		 9586 unsigned int idx;
9587 unsigned int cnt;
2cf0635d 9588 char * endbuf;
252b5132
RH		 9589
9590 found = 1;
9591
74e1a04b
NC		 9592 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9593 printable_section_name (section),
9594 section->sh_info);
252b5132
RH		 9595
9596 printf (_(" Addr: 0x"));
9597 printf_vma (section->sh_addr);
74e1a04b 9598 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9599 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9600 printable_section_name_from_index (section->sh_link));
252b5132 9601
3f5e193b
NC		 9602 edefs = (Elf_External_Verdef *)
9603 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9604 _("version definition section"));
a6e9f9df
AM		 9605 if (!edefs)
9606 break;
59245841 9607 endbuf = (char *) edefs + section->sh_size;
252b5132 9608
b34976b6 9609 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9610 {
2cf0635d
NC		 9611 char * vstart;
9612 Elf_External_Verdef * edef;
b34976b6 9613 Elf_Internal_Verdef ent;
2cf0635d 9614 Elf_External_Verdaux * eaux;
b34976b6
AM		 9615 Elf_Internal_Verdaux aux;
9616 int j;
9617 int isum;
103f02d3 9618
7e26601c
NC		 9619 /* Check for very large indicies. */
9620 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9621 break;
9622
252b5132 9623 vstart = ((char *) edefs) + idx;
54806181
AM		 9624 if (vstart + sizeof (*edef) > endbuf)
9625 break;
252b5132
RH		 9626
9627 edef = (Elf_External_Verdef *) vstart;
9628
9629 ent.vd_version = BYTE_GET (edef->vd_version);
9630 ent.vd_flags = BYTE_GET (edef->vd_flags);
9631 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9632 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9633 ent.vd_hash = BYTE_GET (edef->vd_hash);
9634 ent.vd_aux = BYTE_GET (edef->vd_aux);
9635 ent.vd_next = BYTE_GET (edef->vd_next);
9636
9637 printf (_(" %#06x: Rev: %d Flags: %s"),
9638 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9639
9640 printf (_(" Index: %d Cnt: %d "),
9641 ent.vd_ndx, ent.vd_cnt);
9642
dd24e3da 9643 /* Check for overflow. */
7e26601c 9644 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9645 break;
9646
252b5132
RH		 9647 vstart += ent.vd_aux;
9648
9649 eaux = (Elf_External_Verdaux *) vstart;
9650
9651 aux.vda_name = BYTE_GET (eaux->vda_name);
9652 aux.vda_next = BYTE_GET (eaux->vda_next);
9653
d79b3d50
NC		 9654 if (VALID_DYNAMIC_NAME (aux.vda_name))
9655 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9656 else
9657 printf (_("Name index: %ld\n"), aux.vda_name);
9658
9659 isum = idx + ent.vd_aux;
9660
b34976b6 9661 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9662 {
dd24e3da 9663 /* Check for overflow. */
7e26601c 9664 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9665 break;
9666
252b5132
RH		 9667 isum += aux.vda_next;
9668 vstart += aux.vda_next;
9669
9670 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9671 if (vstart + sizeof (*eaux) > endbuf)
9672 break;
252b5132
RH		 9673
9674 aux.vda_name = BYTE_GET (eaux->vda_name);
9675 aux.vda_next = BYTE_GET (eaux->vda_next);
9676
d79b3d50 9677 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9678 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9679 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9680 else
9681 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9682 isum, j, aux.vda_name);
9683 }
dd24e3da 9684
54806181
AM		 9685 if (j < ent.vd_cnt)
9686 printf (_(" Version def aux past end of section\n"));
252b5132 9687
5d921cbd
NC		 9688 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9689 if (idx + ent.vd_next <= idx)
9690 break;
9691
252b5132
RH		 9692 idx += ent.vd_next;
9693 }
dd24e3da 9694
54806181
AM		 9695 if (cnt < section->sh_info)
9696 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9697
9698 free (edefs);
9699 }
9700 break;
103f02d3 9701
252b5132
RH		 9702 case SHT_GNU_verneed:
9703 {
2cf0635d 9704 Elf_External_Verneed * eneed;
b34976b6
AM		 9705 unsigned int idx;
9706 unsigned int cnt;
2cf0635d 9707 char * endbuf;
252b5132
RH		 9708
9709 found = 1;
9710
72de5009 9711 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9712 printable_section_name (section), section->sh_info);
252b5132
RH		 9713
9714 printf (_(" Addr: 0x"));
9715 printf_vma (section->sh_addr);
72de5009 9716 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9717 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9718 printable_section_name_from_index (section->sh_link));
252b5132 9719
3f5e193b
NC		 9720 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9721 section->sh_offset, 1,
9722 section->sh_size,
9cf03b7e 9723 _("Version Needs section"));
a6e9f9df
AM		 9724 if (!eneed)
9725 break;
59245841 9726 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9727
9728 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9729 {
2cf0635d 9730 Elf_External_Verneed * entry;
b34976b6
AM		 9731 Elf_Internal_Verneed ent;
9732 int j;
9733 int isum;
2cf0635d 9734 char * vstart;
252b5132 9735
7e26601c 9736 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9737 break;
9738
252b5132 9739 vstart = ((char *) eneed) + idx;
54806181
AM		 9740 if (vstart + sizeof (*entry) > endbuf)
9741 break;
252b5132
RH		 9742
9743 entry = (Elf_External_Verneed *) vstart;
9744
9745 ent.vn_version = BYTE_GET (entry->vn_version);
9746 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9747 ent.vn_file = BYTE_GET (entry->vn_file);
9748 ent.vn_aux = BYTE_GET (entry->vn_aux);
9749 ent.vn_next = BYTE_GET (entry->vn_next);
9750
9751 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9752
d79b3d50
NC		 9753 if (VALID_DYNAMIC_NAME (ent.vn_file))
9754 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9755 else
9756 printf (_(" File: %lx"), ent.vn_file);
9757
9758 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9759
dd24e3da 9760 /* Check for overflow. */
7e26601c 9761 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9762 break;
252b5132
RH		 9763 vstart += ent.vn_aux;
9764
9765 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9766 {
2cf0635d 9767 Elf_External_Vernaux * eaux;
b34976b6 9768 Elf_Internal_Vernaux aux;
252b5132 9769
54806181
AM		 9770 if (vstart + sizeof (*eaux) > endbuf)
9771 break;
252b5132
RH		 9772 eaux = (Elf_External_Vernaux *) vstart;
9773
9774 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9775 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9776 aux.vna_other = BYTE_GET (eaux->vna_other);
9777 aux.vna_name = BYTE_GET (eaux->vna_name);
9778 aux.vna_next = BYTE_GET (eaux->vna_next);
9779
d79b3d50 9780 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9781 printf (_(" %#06x: Name: %s"),
d79b3d50 9782 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9783 else
ecc2063b 9784 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9785 isum, aux.vna_name);
9786
9787 printf (_(" Flags: %s Version: %d\n"),
9788 get_ver_flags (aux.vna_flags), aux.vna_other);
9789
dd24e3da 9790 /* Check for overflow. */
53774b7e
NC		 9791 if (aux.vna_next > (size_t) (endbuf - vstart)
9792 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9793 {
9794 warn (_("Invalid vna_next field of %lx\n"),
9795 aux.vna_next);
9796 j = ent.vn_cnt;
9797 break;
9798 }
252b5132
RH		 9799 isum += aux.vna_next;
9800 vstart += aux.vna_next;
9801 }
9cf03b7e 9802
54806181 9803 if (j < ent.vn_cnt)
9cf03b7e 9804 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9805
bcf83b2a 9806 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9807 {
9808 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9809 cnt = section->sh_info;
9810 break;
9811 }
252b5132
RH		 9812 idx += ent.vn_next;
9813 }
9cf03b7e 9814
54806181 9815 if (cnt < section->sh_info)
9cf03b7e 9816 warn (_("Missing Version Needs information\n"));
103f02d3 9817
252b5132
RH		 9818 free (eneed);
9819 }
9820 break;
9821
9822 case SHT_GNU_versym:
9823 {
2cf0635d 9824 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9825 size_t total;
9826 unsigned int cnt;
2cf0635d
NC		 9827 unsigned char * edata;
9828 unsigned short * data;
9829 char * strtab;
9830 Elf_Internal_Sym * symbols;
9831 Elf_Internal_Shdr * string_sec;
ba5cdace 9832 unsigned long num_syms;
d3ba0551 9833 long off;
252b5132 9834
4fbb74a6 9835 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9836 break;
9837
4fbb74a6 9838 link_section = section_headers + section->sh_link;
08d8fa11 9839 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9840
4fbb74a6 9841 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9842 break;
9843
252b5132
RH		 9844 found = 1;
9845
ba5cdace 9846 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9847 if (symbols == NULL)
9848 break;
252b5132 9849
4fbb74a6 9850 string_sec = section_headers + link_section->sh_link;
252b5132 9851
3f5e193b
NC		 9852 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9853 string_sec->sh_size,
9854 _("version string table"));
a6e9f9df 9855 if (!strtab)
0429c154
MS		 9856 {
9857 free (symbols);
9858 break;
9859 }
252b5132 9860
8b73c356
NC		 9861 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9862 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9863
9864 printf (_(" Addr: "));
9865 printf_vma (section->sh_addr);
72de5009 9866 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9867 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9868 printable_section_name (link_section));
252b5132 9869
d3ba0551
AM		 9870 off = offset_from_vma (file,
9871 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9872 total * sizeof (short));
3f5e193b
NC		 9873 edata = (unsigned char *) get_data (NULL, file, off, total,
9874 sizeof (short),
9875 _("version symbol data"));
a6e9f9df
AM		 9876 if (!edata)
9877 {
9878 free (strtab);
0429c154 9879 free (symbols);
a6e9f9df
AM		 9880 break;
9881 }
252b5132 9882
3f5e193b 9883 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9884
9885 for (cnt = total; cnt --;)
b34976b6
AM		 9886 data[cnt] = byte_get (edata + cnt * sizeof (short),
9887 sizeof (short));
252b5132
RH		 9888
9889 free (edata);
9890
9891 for (cnt = 0; cnt < total; cnt += 4)
9892 {
9893 int j, nn;
ab273396
AM		 9894 char *name;
9895 char *invalid = _("*invalid*");
252b5132
RH		 9896
9897 printf (" %03x:", cnt);
9898
9899 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9900 switch (data[cnt + j])
252b5132
RH		 9901 {
9902 case 0:
9903 fputs (_(" 0 (*local*) "), stdout);
9904 break;
9905
9906 case 1:
9907 fputs (_(" 1 (*global*) "), stdout);
9908 break;
9909
9910 default:
c244d050
NC		 9911 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9912 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9913
dd24e3da 9914 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9915 array, break to avoid an out-of-bounds read. */
9916 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9917 {
9918 warn (_("invalid index into symbol array\n"));
9919 break;
9920 }
9921
ab273396
AM		 9922 name = NULL;
9923 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9924 {
b34976b6
AM		 9925 Elf_Internal_Verneed ivn;
9926 unsigned long offset;
252b5132 9927
d93f0186
NC		 9928 offset = offset_from_vma
9929 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9930 sizeof (Elf_External_Verneed));
252b5132 9931
b34976b6 9932 do
252b5132 9933 {
b34976b6
AM		 9934 Elf_Internal_Vernaux ivna;
9935 Elf_External_Verneed evn;
9936 Elf_External_Vernaux evna;
9937 unsigned long a_off;
252b5132 9938
59245841
NC		 9939 if (get_data (&evn, file, offset, sizeof (evn), 1,
9940 _("version need")) == NULL)
9941 break;
0b4362b0 9942
252b5132
RH		 9943 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9944 ivn.vn_next = BYTE_GET (evn.vn_next);
9945
9946 a_off = offset + ivn.vn_aux;
9947
9948 do
9949 {
59245841
NC		 9950 if (get_data (&evna, file, a_off, sizeof (evna),
9951 1, _("version need aux (2)")) == NULL)
9952 {
9953 ivna.vna_next = 0;
9954 ivna.vna_other = 0;
9955 }
9956 else
9957 {
9958 ivna.vna_next = BYTE_GET (evna.vna_next);
9959 ivna.vna_other = BYTE_GET (evna.vna_other);
9960 }
252b5132
RH		 9961
9962 a_off += ivna.vna_next;
9963 }
b34976b6 9964 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9965 && ivna.vna_next != 0);
9966
b34976b6 9967 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9968 {
9969 ivna.vna_name = BYTE_GET (evna.vna_name);
9970
54806181 9971 if (ivna.vna_name >= string_sec->sh_size)
ab273396 9972 name = invalid;
54806181
AM		 9973 else
9974 name = strtab + ivna.vna_name;
252b5132
RH		 9975 break;
9976 }
9977
9978 offset += ivn.vn_next;
9979 }
9980 while (ivn.vn_next);
9981 }
00d93f34 9982
ab273396 9983 if (data[cnt + j] != 0x8001
b34976b6 9984 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 9985 {
b34976b6
AM		 9986 Elf_Internal_Verdef ivd;
9987 Elf_External_Verdef evd;
9988 unsigned long offset;
252b5132 9989
d93f0186
NC		 9990 offset = offset_from_vma
9991 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9992 sizeof evd);
252b5132
RH		 9993
9994 do
9995 {
59245841
NC		 9996 if (get_data (&evd, file, offset, sizeof (evd), 1,
9997 _("version def")) == NULL)
9998 {
9999 ivd.vd_next = 0;
948f632f 10000 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10001 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10002 break;
59245841
NC		 10003 }
10004 else
10005 {
10006 ivd.vd_next = BYTE_GET (evd.vd_next);
10007 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10008 }
252b5132
RH		 10009
10010 offset += ivd.vd_next;
10011 }
c244d050 10012 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10013 && ivd.vd_next != 0);
10014
c244d050 10015 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10016 {
b34976b6
AM		 10017 Elf_External_Verdaux evda;
10018 Elf_Internal_Verdaux ivda;
252b5132
RH		 10019
10020 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10021
59245841
NC		 10022 if (get_data (&evda, file,
10023 offset - ivd.vd_next + ivd.vd_aux,
10024 sizeof (evda), 1,
10025 _("version def aux")) == NULL)
10026 break;
252b5132
RH		 10027
10028 ivda.vda_name = BYTE_GET (evda.vda_name);
10029
54806181 10030 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10031 name = invalid;
10032 else if (name != NULL && name != invalid)
10033 name = _("*both*");
54806181
AM		 10034 else
10035 name = strtab + ivda.vda_name;
252b5132
RH		 10036 }
10037 }
ab273396
AM		 10038 if (name != NULL)
10039 nn += printf ("(%s%-*s",
10040 name,
10041 12 - (int) strlen (name),
10042 ")");
252b5132
RH		 10043
10044 if (nn < 18)
10045 printf ("%*c", 18 - nn, ' ');
10046 }
10047
10048 putchar ('\n');
10049 }
10050
10051 free (data);
10052 free (strtab);
10053 free (symbols);
10054 }
10055 break;
103f02d3 10056
252b5132
RH		 10057 default:
10058 break;
10059 }
10060 }
10061
10062 if (! found)
10063 printf (_("\nNo version information found in this file.\n"));
10064
10065 return 1;
10066}
10067
d1133906 10068static const char *
d3ba0551 10069get_symbol_binding (unsigned int binding)
252b5132 10070{
b34976b6 10071 static char buff[32];
252b5132
RH		 10072
10073 switch (binding)
10074 {
b34976b6
AM		 10075 case STB_LOCAL: return "LOCAL";
10076 case STB_GLOBAL: return "GLOBAL";
10077 case STB_WEAK: return "WEAK";
252b5132
RH		 10078 default:
10079 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10080 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10081 binding);
252b5132 10082 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10083 {
10084 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10085 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10086 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10087 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10088 return "UNIQUE";
10089 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10090 }
252b5132 10091 else
e9e44622 10092 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10093 return buff;
10094 }
10095}
10096
d1133906 10097static const char *
d3ba0551 10098get_symbol_type (unsigned int type)
252b5132 10099{
b34976b6 10100 static char buff[32];
252b5132
RH		 10101
10102 switch (type)
10103 {
b34976b6
AM		 10104 case STT_NOTYPE: return "NOTYPE";
10105 case STT_OBJECT: return "OBJECT";
10106 case STT_FUNC: return "FUNC";
10107 case STT_SECTION: return "SECTION";
10108 case STT_FILE: return "FILE";
10109 case STT_COMMON: return "COMMON";
10110 case STT_TLS: return "TLS";
15ab5209
DB		 10111 case STT_RELC: return "RELC";
10112 case STT_SRELC: return "SRELC";
252b5132
RH		 10113 default:
10114 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10115 {
3510a7b8
NC		 10116 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10117 return "THUMB_FUNC";
103f02d3 10118
351b4b40 10119 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10120 return "REGISTER";
10121
10122 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10123 return "PARISC_MILLI";
10124
e9e44622 10125 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10126 }
252b5132 10127 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10128 {
10129 if (elf_header.e_machine == EM_PARISC)
10130 {
10131 if (type == STT_HP_OPAQUE)
10132 return "HP_OPAQUE";
10133 if (type == STT_HP_STUB)
10134 return "HP_STUB";
10135 }
10136
d8045f23 10137 if (type == STT_GNU_IFUNC
9c55345c 10138 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10139 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10140 /* GNU is still using the default value 0. */
d8045f23
NC		 10141 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10142 return "IFUNC";
10143
e9e44622 10144 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10145 }
252b5132 10146 else
e9e44622 10147 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10148 return buff;
10149 }
10150}
10151
d1133906 10152static const char *
d3ba0551 10153get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10154{
10155 switch (visibility)
10156 {
b34976b6
AM		 10157 case STV_DEFAULT: return "DEFAULT";
10158 case STV_INTERNAL: return "INTERNAL";
10159 case STV_HIDDEN: return "HIDDEN";
d1133906 10160 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10161 default:
10162 error (_("Unrecognized visibility value: %u"), visibility);
10163 return _("<unknown>");
d1133906
NC		 10164 }
10165}
10166
5e2b0d47
NC		 10167static const char *
10168get_mips_symbol_other (unsigned int other)
10169{
10170 switch (other)
10171 {
df58fc94
RS		 10172 case STO_OPTIONAL:
10173 return "OPTIONAL";
10174 case STO_MIPS_PLT:
10175 return "MIPS PLT";
10176 case STO_MIPS_PIC:
10177 return "MIPS PIC";
10178 case STO_MICROMIPS:
10179 return "MICROMIPS";
10180 case STO_MICROMIPS | STO_MIPS_PIC:
10181 return "MICROMIPS, MIPS PIC";
10182 case STO_MIPS16:
10183 return "MIPS16";
10184 default:
10185 return NULL;
5e2b0d47
NC		 10186 }
10187}
10188
28f997cf
TG		 10189static const char *
10190get_ia64_symbol_other (unsigned int other)
10191{
10192 if (is_ia64_vms ())
10193 {
10194 static char res[32];
10195
10196 res[0] = 0;
10197
10198 /* Function types is for images and .STB files only. */
10199 switch (elf_header.e_type)
10200 {
10201 case ET_DYN:
10202 case ET_EXEC:
10203 switch (VMS_ST_FUNC_TYPE (other))
10204 {
10205 case VMS_SFT_CODE_ADDR:
10206 strcat (res, " CA");
10207 break;
10208 case VMS_SFT_SYMV_IDX:
10209 strcat (res, " VEC");
10210 break;
10211 case VMS_SFT_FD:
10212 strcat (res, " FD");
10213 break;
10214 case VMS_SFT_RESERVE:
10215 strcat (res, " RSV");
10216 break;
10217 default:
bee0ee85
NC		 10218 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10219 VMS_ST_FUNC_TYPE (other));
10220 strcat (res, " <unknown>");
10221 break;
28f997cf
TG		 10222 }
10223 break;
10224 default:
10225 break;
10226 }
10227 switch (VMS_ST_LINKAGE (other))
10228 {
10229 case VMS_STL_IGNORE:
10230 strcat (res, " IGN");
10231 break;
10232 case VMS_STL_RESERVE:
10233 strcat (res, " RSV");
10234 break;
10235 case VMS_STL_STD:
10236 strcat (res, " STD");
10237 break;
10238 case VMS_STL_LNK:
10239 strcat (res, " LNK");
10240 break;
10241 default:
bee0ee85
NC		 10242 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10243 VMS_ST_LINKAGE (other));
10244 strcat (res, " <unknown>");
10245 break;
28f997cf
TG		 10246 }
10247
10248 if (res[0] != 0)
10249 return res + 1;
10250 else
10251 return res;
10252 }
10253 return NULL;
10254}
10255
6911b7dc
AM		 10256static const char *
10257get_ppc64_symbol_other (unsigned int other)
10258{
10259 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10260 {
10261 static char buf[32];
10262 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10263 PPC64_LOCAL_ENTRY_OFFSET (other));
10264 return buf;
10265 }
10266 return NULL;
10267}
10268
5e2b0d47
NC		 10269static const char *
10270get_symbol_other (unsigned int other)
10271{
10272 const char * result = NULL;
10273 static char buff [32];
10274
10275 if (other == 0)
10276 return "";
10277
10278 switch (elf_header.e_machine)
10279 {
10280 case EM_MIPS:
10281 result = get_mips_symbol_other (other);
28f997cf
TG		 10282 break;
10283 case EM_IA_64:
10284 result = get_ia64_symbol_other (other);
10285 break;
6911b7dc
AM		 10286 case EM_PPC64:
10287 result = get_ppc64_symbol_other (other);
10288 break;
5e2b0d47
NC		 10289 default:
10290 break;
10291 }
10292
10293 if (result)
10294 return result;
10295
10296 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10297 return buff;
10298}
10299
d1133906 10300static const char *
d3ba0551 10301get_symbol_index_type (unsigned int type)
252b5132 10302{
b34976b6 10303 static char buff[32];
5cf1065c 10304
252b5132
RH		 10305 switch (type)
10306 {
b34976b6
AM		 10307 case SHN_UNDEF: return "UND";
10308 case SHN_ABS: return "ABS";
10309 case SHN_COMMON: return "COM";
252b5132 10310 default:
9ce701e2
L		 10311 if (type == SHN_IA_64_ANSI_COMMON
10312 && elf_header.e_machine == EM_IA_64
10313 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10314 return "ANSI_COM";
8a9036a4 10315 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10316 || elf_header.e_machine == EM_L1OM
10317 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10318 && type == SHN_X86_64_LCOMMON)
10319 return "LARGE_COM";
ac145307
BS		 10320 else if ((type == SHN_MIPS_SCOMMON
10321 && elf_header.e_machine == EM_MIPS)
10322 || (type == SHN_TIC6X_SCOMMON
10323 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10324 return "SCOM";
10325 else if (type == SHN_MIPS_SUNDEFINED
10326 && elf_header.e_machine == EM_MIPS)
10327 return "SUND";
9ce701e2 10328 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10329 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10330 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10331 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10332 else if (type >= SHN_LORESERVE)
10333 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10334 else if (type >= elf_header.e_shnum)
e0a31db1 10335 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10336 else
232e7cb8 10337 sprintf (buff, "%3d", type);
5cf1065c 10338 break;
252b5132 10339 }
5cf1065c
NC		 10340
10341 return buff;
252b5132
RH		 10342}
10343
66543521 10344static bfd_vma *
57028622 10345get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10346{
2cf0635d
NC		 10347 unsigned char * e_data;
10348 bfd_vma * i_data;
252b5132 10349
57028622
NC		 10350 /* If the size_t type is smaller than the bfd_size_type, eg because
10351 you are building a 32-bit tool on a 64-bit host, then make sure
10352 that when (number) is cast to (size_t) no information is lost. */
10353 if (sizeof (size_t) < sizeof (bfd_size_type)
10354 && (bfd_size_type) ((size_t) number) != number)
10355 {
10356 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10357 (unsigned long long) number, ent_size);
10358 return NULL;
10359 }
948f632f 10360
3102e897
NC		 10361 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10362 attempting to allocate memory when the read is bound to fail. */
10363 if (ent_size * number > current_file_size)
10364 {
57028622
NC		 10365 error (_("Invalid number of dynamic entries: %llu\n"),
10366 (unsigned long long) number);
3102e897
NC		 10367 return NULL;
10368 }
10369
57028622 10370 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10371 if (e_data == NULL)
10372 {
57028622
NC		 10373 error (_("Out of memory reading %llu dynamic entries\n"),
10374 (unsigned long long) number);
252b5132
RH		 10375 return NULL;
10376 }
10377
57028622 10378 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10379 {
57028622
NC		 10380 error (_("Unable to read in %llu bytes of dynamic data\n"),
10381 (unsigned long long) (number * ent_size));
3102e897 10382 free (e_data);
252b5132
RH		 10383 return NULL;
10384 }
10385
57028622 10386 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10387 if (i_data == NULL)
10388 {
57028622
NC		 10389 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10390 (unsigned long long) number);
252b5132
RH		 10391 free (e_data);
10392 return NULL;
10393 }
10394
10395 while (number--)
66543521 10396 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10397
10398 free (e_data);
10399
10400 return i_data;
10401}
10402
6bd1a22c
L		 10403static void
10404print_dynamic_symbol (bfd_vma si, unsigned long hn)
10405{
2cf0635d 10406 Elf_Internal_Sym * psym;
6bd1a22c
L		 10407 int n;
10408
6bd1a22c
L		 10409 n = print_vma (si, DEC_5);
10410 if (n < 5)
0b4362b0 10411 fputs (&" "[n], stdout);
6bd1a22c 10412 printf (" %3lu: ", hn);
e0a31db1
NC		 10413
10414 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10415 {
3102e897
NC		 10416 printf (_("<No info available for dynamic symbol number %lu>\n"),
10417 (unsigned long) si);
e0a31db1
NC		 10418 return;
10419 }
10420
10421 psym = dynamic_symbols + si;
6bd1a22c
L		 10422 print_vma (psym->st_value, LONG_HEX);
10423 putchar (' ');
10424 print_vma (psym->st_size, DEC_5);
10425
f4be36b3
AM		 10426 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10427 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10428 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10429 /* Check to see if any other bits in the st_other field are set.
10430 Note - displaying this information disrupts the layout of the
10431 table being generated, but for the moment this case is very
10432 rare. */
10433 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10434 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10435 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10436 if (VALID_DYNAMIC_NAME (psym->st_name))
10437 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10438 else
2b692964 10439 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10440 putchar ('\n');
10441}
10442
bb4d2ac2
L		 10443static const char *
10444get_symbol_version_string (FILE *file, int is_dynsym,
10445 const char *strtab,
10446 unsigned long int strtab_size,
10447 unsigned int si, Elf_Internal_Sym *psym,
10448 enum versioned_symbol_info *sym_info,
10449 unsigned short *vna_other)
10450{
ab273396
AM		 10451 unsigned char data[2];
10452 unsigned short vers_data;
10453 unsigned long offset;
bb4d2ac2 10454
ab273396
AM		 10455 if (!is_dynsym
10456 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10457 return NULL;
bb4d2ac2 10458
ab273396
AM		 10459 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10460 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10461
ab273396
AM		 10462 if (get_data (&data, file, offset + si * sizeof (vers_data),
10463 sizeof (data), 1, _("version data")) == NULL)
10464 return NULL;
10465
10466 vers_data = byte_get (data, 2);
bb4d2ac2 10467
ab273396
AM		 10468 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10469 return NULL;
bb4d2ac2 10470
ab273396
AM		 10471 /* Usually we'd only see verdef for defined symbols, and verneed for
10472 undefined symbols. However, symbols defined by the linker in
10473 .dynbss for variables copied from a shared library in order to
10474 avoid text relocations are defined yet have verneed. We could
10475 use a heuristic to detect the special case, for example, check
10476 for verneed first on symbols defined in SHT_NOBITS sections, but
10477 it is simpler and more reliable to just look for both verdef and
10478 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10479
ab273396
AM		 10480 if (psym->st_shndx != SHN_UNDEF
10481 && vers_data != 0x8001
10482 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10483 {
10484 Elf_Internal_Verdef ivd;
10485 Elf_Internal_Verdaux ivda;
10486 Elf_External_Verdaux evda;
10487 unsigned long off;
bb4d2ac2 10488
ab273396
AM		 10489 off = offset_from_vma (file,
10490 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10491 sizeof (Elf_External_Verdef));
10492
10493 do
bb4d2ac2 10494 {
ab273396
AM		 10495 Elf_External_Verdef evd;
10496
10497 if (get_data (&evd, file, off, sizeof (evd), 1,
10498 _("version def")) == NULL)
10499 {
10500 ivd.vd_ndx = 0;
10501 ivd.vd_aux = 0;
10502 ivd.vd_next = 0;
10503 }
10504 else
bb4d2ac2 10505 {
ab273396
AM		 10506 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10507 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10508 ivd.vd_next = BYTE_GET (evd.vd_next);
10509 }
bb4d2ac2 10510
ab273396
AM		 10511 off += ivd.vd_next;
10512 }
10513 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10514
ab273396
AM		 10515 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10516 {
10517 off -= ivd.vd_next;
10518 off += ivd.vd_aux;
bb4d2ac2 10519
ab273396
AM		 10520 if (get_data (&evda, file, off, sizeof (evda), 1,
10521 _("version def aux")) != NULL)
10522 {
10523 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10524
ab273396
AM		 10525 if (psym->st_name != ivda.vda_name)
10526 {
10527 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10528 ? symbol_hidden : symbol_public);
10529 return (ivda.vda_name < strtab_size
10530 ? strtab + ivda.vda_name : _("<corrupt>"));
10531 }
10532 }
10533 }
10534 }
bb4d2ac2 10535
ab273396
AM		 10536 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10537 {
10538 Elf_External_Verneed evn;
10539 Elf_Internal_Verneed ivn;
10540 Elf_Internal_Vernaux ivna;
bb4d2ac2 10541
ab273396
AM		 10542 offset = offset_from_vma (file,
10543 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10544 sizeof evn);
10545 do
10546 {
10547 unsigned long vna_off;
bb4d2ac2 10548
ab273396
AM		 10549 if (get_data (&evn, file, offset, sizeof (evn), 1,
10550 _("version need")) == NULL)
10551 {
10552 ivna.vna_next = 0;
10553 ivna.vna_other = 0;
10554 ivna.vna_name = 0;
10555 break;
10556 }
bb4d2ac2 10557
ab273396
AM		 10558 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10559 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10560
ab273396 10561 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10562
ab273396
AM		 10563 do
10564 {
10565 Elf_External_Vernaux evna;
bb4d2ac2 10566
ab273396
AM		 10567 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10568 _("version need aux (3)")) == NULL)
bb4d2ac2 10569 {
ab273396
AM		 10570 ivna.vna_next = 0;
10571 ivna.vna_other = 0;
10572 ivna.vna_name = 0;
bb4d2ac2 10573 }
bb4d2ac2 10574 else
bb4d2ac2 10575 {
ab273396
AM		 10576 ivna.vna_other = BYTE_GET (evna.vna_other);
10577 ivna.vna_next = BYTE_GET (evna.vna_next);
10578 ivna.vna_name = BYTE_GET (evna.vna_name);
10579 }
bb4d2ac2 10580
ab273396
AM		 10581 vna_off += ivna.vna_next;
10582 }
10583 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10584
ab273396
AM		 10585 if (ivna.vna_other == vers_data)
10586 break;
bb4d2ac2 10587
ab273396
AM		 10588 offset += ivn.vn_next;
10589 }
10590 while (ivn.vn_next != 0);
bb4d2ac2 10591
ab273396
AM		 10592 if (ivna.vna_other == vers_data)
10593 {
10594 *sym_info = symbol_undefined;
10595 *vna_other = ivna.vna_other;
10596 return (ivna.vna_name < strtab_size
10597 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10598 }
10599 }
ab273396 10600 return NULL;
bb4d2ac2
L		 10601}
10602
e3c8793a 10603/* Dump the symbol table. */
252b5132 10604static int
2cf0635d 10605process_symbol_table (FILE * file)
252b5132 10606{
2cf0635d 10607 Elf_Internal_Shdr * section;
8b73c356
NC		 10608 bfd_size_type nbuckets = 0;
10609 bfd_size_type nchains = 0;
2cf0635d
NC		 10610 bfd_vma * buckets = NULL;
10611 bfd_vma * chains = NULL;
fdc90cb4 10612 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10613 bfd_vma * gnubuckets = NULL;
10614 bfd_vma * gnuchains = NULL;
6bd1a22c 10615 bfd_vma gnusymidx = 0;
071436c6 10616 bfd_size_type ngnuchains = 0;
252b5132 10617
2c610e4b 10618 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10619 return 1;
10620
6bd1a22c
L		 10621 if (dynamic_info[DT_HASH]
10622 && (do_histogram
2c610e4b
L		 10623 || (do_using_dynamic
10624 && !do_dyn_syms
10625 && dynamic_strings != NULL)))
252b5132 10626 {
66543521
AM		 10627 unsigned char nb[8];
10628 unsigned char nc[8];
8b73c356 10629 unsigned int hash_ent_size = 4;
66543521
AM		 10630
10631 if ((elf_header.e_machine == EM_ALPHA
10632 || elf_header.e_machine == EM_S390
10633 || elf_header.e_machine == EM_S390_OLD)
10634 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10635 hash_ent_size = 8;
10636
fb52b2f4
NC		 10637 if (fseek (file,
10638 (archive_file_offset
10639 + offset_from_vma (file, dynamic_info[DT_HASH],
10640 sizeof nb + sizeof nc)),
d93f0186 10641 SEEK_SET))
252b5132 10642 {
591a748a 10643 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10644 goto no_hash;
252b5132
RH		 10645 }
10646
66543521 10647 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10648 {
10649 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10650 goto no_hash;
252b5132
RH		 10651 }
10652
66543521 10653 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10654 {
10655 error (_("Failed to read in number of chains\n"));
d3a44ec6 10656 goto no_hash;
252b5132
RH		 10657 }
10658
66543521
AM		 10659 nbuckets = byte_get (nb, hash_ent_size);
10660 nchains = byte_get (nc, hash_ent_size);
252b5132 10661
66543521
AM		 10662 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10663 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10664
d3a44ec6 10665 no_hash:
252b5132 10666 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10667 {
10668 if (do_using_dynamic)
10669 return 0;
10670 free (buckets);
10671 free (chains);
10672 buckets = NULL;
10673 chains = NULL;
10674 nbuckets = 0;
10675 nchains = 0;
10676 }
252b5132
RH		 10677 }
10678
6bd1a22c
L		 10679 if (dynamic_info_DT_GNU_HASH
10680 && (do_histogram
2c610e4b
L		 10681 || (do_using_dynamic
10682 && !do_dyn_syms
10683 && dynamic_strings != NULL)))
252b5132 10684 {
6bd1a22c
L		 10685 unsigned char nb[16];
10686 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10687 bfd_vma buckets_vma;
10688
10689 if (fseek (file,
10690 (archive_file_offset
10691 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10692 sizeof nb)),
10693 SEEK_SET))
10694 {
10695 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10696 goto no_gnu_hash;
6bd1a22c 10697 }
252b5132 10698
6bd1a22c
L		 10699 if (fread (nb, 16, 1, file) != 1)
10700 {
10701 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10702 goto no_gnu_hash;
6bd1a22c
L		 10703 }
10704
10705 ngnubuckets = byte_get (nb, 4);
10706 gnusymidx = byte_get (nb + 4, 4);
10707 bitmaskwords = byte_get (nb + 8, 4);
10708 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10709 if (is_32bit_elf)
6bd1a22c 10710 buckets_vma += bitmaskwords * 4;
f7a99963 10711 else
6bd1a22c 10712 buckets_vma += bitmaskwords * 8;
252b5132 10713
6bd1a22c
L		 10714 if (fseek (file,
10715 (archive_file_offset
10716 + offset_from_vma (file, buckets_vma, 4)),
10717 SEEK_SET))
252b5132 10718 {
6bd1a22c 10719 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10720 goto no_gnu_hash;
6bd1a22c
L		 10721 }
10722
10723 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10724
6bd1a22c 10725 if (gnubuckets == NULL)
d3a44ec6 10726 goto no_gnu_hash;
6bd1a22c
L		 10727
10728 for (i = 0; i < ngnubuckets; i++)
10729 if (gnubuckets[i] != 0)
10730 {
10731 if (gnubuckets[i] < gnusymidx)
10732 return 0;
10733
10734 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10735 maxchain = gnubuckets[i];
10736 }
10737
10738 if (maxchain == 0xffffffff)
d3a44ec6 10739 goto no_gnu_hash;
6bd1a22c
L		 10740
10741 maxchain -= gnusymidx;
10742
10743 if (fseek (file,
10744 (archive_file_offset
10745 + offset_from_vma (file, buckets_vma
10746 + 4 * (ngnubuckets + maxchain), 4)),
10747 SEEK_SET))
10748 {
10749 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10750 goto no_gnu_hash;
6bd1a22c
L		 10751 }
10752
10753 do
10754 {
10755 if (fread (nb, 4, 1, file) != 1)
252b5132 10756 {
6bd1a22c 10757 error (_("Failed to determine last chain length\n"));
d3a44ec6 10758 goto no_gnu_hash;
6bd1a22c 10759 }
252b5132 10760
6bd1a22c 10761 if (maxchain + 1 == 0)
d3a44ec6 10762 goto no_gnu_hash;
252b5132 10763
6bd1a22c
L		 10764 ++maxchain;
10765 }
10766 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10767
6bd1a22c
L		 10768 if (fseek (file,
10769 (archive_file_offset
10770 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10771 SEEK_SET))
10772 {
10773 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10774 goto no_gnu_hash;
6bd1a22c
L		 10775 }
10776
10777 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10778 ngnuchains = maxchain;
6bd1a22c 10779
d3a44ec6 10780 no_gnu_hash:
6bd1a22c 10781 if (gnuchains == NULL)
d3a44ec6
JJ		 10782 {
10783 free (gnubuckets);
d3a44ec6
JJ		 10784 gnubuckets = NULL;
10785 ngnubuckets = 0;
f64fddf1
NC		 10786 if (do_using_dynamic)
10787 return 0;
d3a44ec6 10788 }
6bd1a22c
L		 10789 }
10790
10791 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10792 && do_syms
10793 && do_using_dynamic
3102e897
NC		 10794 && dynamic_strings != NULL
10795 && dynamic_symbols != NULL)
6bd1a22c
L		 10796 {
10797 unsigned long hn;
10798
10799 if (dynamic_info[DT_HASH])
10800 {
10801 bfd_vma si;
10802
10803 printf (_("\nSymbol table for image:\n"));
10804 if (is_32bit_elf)
10805 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10806 else
10807 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10808
10809 for (hn = 0; hn < nbuckets; hn++)
10810 {
10811 if (! buckets[hn])
10812 continue;
10813
10814 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10815 print_dynamic_symbol (si, hn);
252b5132
RH		 10816 }
10817 }
6bd1a22c
L		 10818
10819 if (dynamic_info_DT_GNU_HASH)
10820 {
10821 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10822 if (is_32bit_elf)
10823 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10824 else
10825 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10826
10827 for (hn = 0; hn < ngnubuckets; ++hn)
10828 if (gnubuckets[hn] != 0)
10829 {
10830 bfd_vma si = gnubuckets[hn];
10831 bfd_vma off = si - gnusymidx;
10832
10833 do
10834 {
10835 print_dynamic_symbol (si, hn);
10836 si++;
10837 }
071436c6 10838 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10839 }
10840 }
252b5132 10841 }
8b73c356
NC		 10842 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10843 && section_headers != NULL)
252b5132 10844 {
b34976b6 10845 unsigned int i;
252b5132
RH		 10846
10847 for (i = 0, section = section_headers;
10848 i < elf_header.e_shnum;
10849 i++, section++)
10850 {
b34976b6 10851 unsigned int si;
2cf0635d 10852 char * strtab = NULL;
c256ffe7 10853 unsigned long int strtab_size = 0;
2cf0635d
NC		 10854 Elf_Internal_Sym * symtab;
10855 Elf_Internal_Sym * psym;
ba5cdace 10856 unsigned long num_syms;
252b5132 10857
2c610e4b
L		 10858 if ((section->sh_type != SHT_SYMTAB
10859 && section->sh_type != SHT_DYNSYM)
10860 || (!do_syms
10861 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10862 continue;
10863
dd24e3da
NC		 10864 if (section->sh_entsize == 0)
10865 {
10866 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10867 printable_section_name (section));
dd24e3da
NC		 10868 continue;
10869 }
10870
252b5132 10871 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10872 printable_section_name (section),
252b5132 10873 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10874
f7a99963 10875 if (is_32bit_elf)
ca47b30c 10876 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10877 else
ca47b30c 10878 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10879
ba5cdace 10880 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10881 if (symtab == NULL)
10882 continue;
10883
10884 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10885 {
10886 strtab = string_table;
10887 strtab_size = string_table_length;
10888 }
4fbb74a6 10889 else if (section->sh_link < elf_header.e_shnum)
252b5132 10890 {
2cf0635d 10891 Elf_Internal_Shdr * string_sec;
252b5132 10892
4fbb74a6 10893 string_sec = section_headers + section->sh_link;
252b5132 10894
3f5e193b
NC		 10895 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10896 1, string_sec->sh_size,
10897 _("string table"));
c256ffe7 10898 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10899 }
10900
ba5cdace 10901 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10902 {
bb4d2ac2
L		 10903 const char *version_string;
10904 enum versioned_symbol_info sym_info;
10905 unsigned short vna_other;
10906
5e220199 10907 printf ("%6d: ", si);
f7a99963
NC		 10908 print_vma (psym->st_value, LONG_HEX);
10909 putchar (' ');
10910 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10911 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10912 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10913 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10914 /* Check to see if any other bits in the st_other field are set.
10915 Note - displaying this information disrupts the layout of the
10916 table being generated, but for the moment this case is very rare. */
10917 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10918 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10919 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10920 print_symbol (25, psym->st_name < strtab_size
2b692964 10921 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10922
bb4d2ac2
L		 10923 version_string
10924 = get_symbol_version_string (file,
10925 section->sh_type == SHT_DYNSYM,
10926 strtab, strtab_size, si,
10927 psym, &sym_info, &vna_other);
10928 if (version_string)
252b5132 10929 {
bb4d2ac2
L		 10930 if (sym_info == symbol_undefined)
10931 printf ("@%s (%d)", version_string, vna_other);
10932 else
10933 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10934 version_string);
252b5132
RH		 10935 }
10936
10937 putchar ('\n');
10938 }
10939
10940 free (symtab);
10941 if (strtab != string_table)
10942 free (strtab);
10943 }
10944 }
10945 else if (do_syms)
10946 printf
10947 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10948
10949 if (do_histogram && buckets != NULL)
10950 {
2cf0635d
NC		 10951 unsigned long * lengths;
10952 unsigned long * counts;
66543521
AM		 10953 unsigned long hn;
10954 bfd_vma si;
10955 unsigned long maxlength = 0;
10956 unsigned long nzero_counts = 0;
10957 unsigned long nsyms = 0;
94d15024 10958 unsigned long chained;
252b5132 10959
66543521
AM		 10960 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10961 (unsigned long) nbuckets);
252b5132 10962
3f5e193b 10963 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10964 if (lengths == NULL)
10965 {
8b73c356 10966 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10967 return 0;
10968 }
8b73c356
NC		 10969
10970 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10971 for (hn = 0; hn < nbuckets; ++hn)
10972 {
94d15024
MF		 10973 for (si = buckets[hn], chained = 0;
10974 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
10975 si = chains[si], ++chained)
252b5132 10976 {
b34976b6 10977 ++nsyms;
252b5132 10978 if (maxlength < ++lengths[hn])
b34976b6 10979 ++maxlength;
252b5132 10980 }
94d15024
MF		 10981
10982 /* PR binutils/17531: A corrupt binary could contain broken
10983 histogram data. Do not go into an infinite loop trying
10984 to process it. */
10985 if (chained > nchains)
10986 {
10987 error (_("histogram chain is corrupt\n"));
10988 break;
10989 }
252b5132
RH		 10990 }
10991
3f5e193b 10992 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 10993 if (counts == NULL)
10994 {
b2e951ec 10995 free (lengths);
8b73c356 10996 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 10997 return 0;
10998 }
10999
11000 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11001 ++counts[lengths[hn]];
252b5132 11002
103f02d3 11003 if (nbuckets > 0)
252b5132 11004 {
66543521
AM		 11005 unsigned long i;
11006 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11007 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11008 for (i = 1; i <= maxlength; ++i)
103f02d3 11009 {
66543521
AM		 11010 nzero_counts += counts[i] * i;
11011 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11012 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11013 (nzero_counts * 100.0) / nsyms);
11014 }
252b5132
RH		 11015 }
11016
11017 free (counts);
11018 free (lengths);
11019 }
11020
11021 if (buckets != NULL)
11022 {
11023 free (buckets);
11024 free (chains);
11025 }
11026
d3a44ec6 11027 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11028 {
2cf0635d
NC		 11029 unsigned long * lengths;
11030 unsigned long * counts;
fdc90cb4
JJ		 11031 unsigned long hn;
11032 unsigned long maxlength = 0;
11033 unsigned long nzero_counts = 0;
11034 unsigned long nsyms = 0;
fdc90cb4 11035
8b73c356
NC		 11036 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11037 (unsigned long) ngnubuckets);
11038
3f5e193b 11039 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11040 if (lengths == NULL)
11041 {
8b73c356 11042 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11043 return 0;
11044 }
11045
fdc90cb4
JJ		 11046 printf (_(" Length Number %% of total Coverage\n"));
11047
11048 for (hn = 0; hn < ngnubuckets; ++hn)
11049 if (gnubuckets[hn] != 0)
11050 {
11051 bfd_vma off, length = 1;
11052
6bd1a22c 11053 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11054 /* PR 17531 file: 010-77222-0.004. */
11055 off < ngnuchains && (gnuchains[off] & 1) == 0;
11056 ++off)
fdc90cb4
JJ		 11057 ++length;
11058 lengths[hn] = length;
11059 if (length > maxlength)
11060 maxlength = length;
11061 nsyms += length;
11062 }
11063
3f5e193b 11064 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11065 if (counts == NULL)
11066 {
b2e951ec 11067 free (lengths);
8b73c356 11068 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11069 return 0;
11070 }
11071
11072 for (hn = 0; hn < ngnubuckets; ++hn)
11073 ++counts[lengths[hn]];
11074
11075 if (ngnubuckets > 0)
11076 {
11077 unsigned long j;
11078 printf (" 0 %-10lu (%5.1f%%)\n",
11079 counts[0], (counts[0] * 100.0) / ngnubuckets);
11080 for (j = 1; j <= maxlength; ++j)
11081 {
11082 nzero_counts += counts[j] * j;
11083 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11084 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11085 (nzero_counts * 100.0) / nsyms);
11086 }
11087 }
11088
11089 free (counts);
11090 free (lengths);
11091 free (gnubuckets);
11092 free (gnuchains);
11093 }
11094
252b5132
RH		 11095 return 1;
11096}
11097
11098static int
2cf0635d 11099process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11100{
b4c96d0d 11101 unsigned int i;
252b5132
RH		 11102
11103 if (dynamic_syminfo == NULL
11104 || !do_dynamic)
11105 /* No syminfo, this is ok. */
11106 return 1;
11107
11108 /* There better should be a dynamic symbol section. */
11109 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11110 return 0;
11111
11112 if (dynamic_addr)
11113 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11114 dynamic_syminfo_offset, dynamic_syminfo_nent);
11115
11116 printf (_(" Num: Name BoundTo Flags\n"));
11117 for (i = 0; i < dynamic_syminfo_nent; ++i)
11118 {
11119 unsigned short int flags = dynamic_syminfo[i].si_flags;
11120
31104126 11121 printf ("%4d: ", i);
4082ef84
NC		 11122 if (i >= num_dynamic_syms)
11123 printf (_("<corrupt index>"));
11124 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11125 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11126 else
2b692964 11127 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11128 putchar (' ');
252b5132
RH		 11129
11130 switch (dynamic_syminfo[i].si_boundto)
11131 {
11132 case SYMINFO_BT_SELF:
11133 fputs ("SELF ", stdout);
11134 break;
11135 case SYMINFO_BT_PARENT:
11136 fputs ("PARENT ", stdout);
11137 break;
11138 default:
11139 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11140 && dynamic_syminfo[i].si_boundto < dynamic_nent
11141 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11142 {
d79b3d50 11143 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11144 putchar (' ' );
11145 }
252b5132
RH		 11146 else
11147 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11148 break;
11149 }
11150
11151 if (flags & SYMINFO_FLG_DIRECT)
11152 printf (" DIRECT");
11153 if (flags & SYMINFO_FLG_PASSTHRU)
11154 printf (" PASSTHRU");
11155 if (flags & SYMINFO_FLG_COPY)
11156 printf (" COPY");
11157 if (flags & SYMINFO_FLG_LAZYLOAD)
11158 printf (" LAZYLOAD");
11159
11160 puts ("");
11161 }
11162
11163 return 1;
11164}
11165
cf13d699
NC		 11166/* Check to see if the given reloc needs to be handled in a target specific
11167 manner. If so then process the reloc and return TRUE otherwise return
11168 FALSE. */
09c11c86 11169
cf13d699
NC		 11170static bfd_boolean
11171target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11172 unsigned char * start,
11173 Elf_Internal_Sym * symtab)
252b5132 11174{
cf13d699 11175 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11176
cf13d699 11177 switch (elf_header.e_machine)
252b5132 11178 {
13761a11
NC		 11179 case EM_MSP430:
11180 case EM_MSP430_OLD:
11181 {
11182 static Elf_Internal_Sym * saved_sym = NULL;
11183
11184 switch (reloc_type)
11185 {
11186 case 10: /* R_MSP430_SYM_DIFF */
11187 if (uses_msp430x_relocs ())
11188 break;
11189 case 21: /* R_MSP430X_SYM_DIFF */
11190 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11191 return TRUE;
11192
11193 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11194 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11195 goto handle_sym_diff;
0b4362b0 11196
13761a11
NC		 11197 case 5: /* R_MSP430_16_BYTE */
11198 case 9: /* R_MSP430_8 */
11199 if (uses_msp430x_relocs ())
11200 break;
11201 goto handle_sym_diff;
11202
11203 case 2: /* R_MSP430_ABS16 */
11204 case 15: /* R_MSP430X_ABS16 */
11205 if (! uses_msp430x_relocs ())
11206 break;
11207 goto handle_sym_diff;
0b4362b0 11208
13761a11
NC		 11209 handle_sym_diff:
11210 if (saved_sym != NULL)
11211 {
11212 bfd_vma value;
11213
11214 value = reloc->r_addend
11215 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11216 - saved_sym->st_value);
11217
11218 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11219
11220 saved_sym = NULL;
11221 return TRUE;
11222 }
11223 break;
11224
11225 default:
11226 if (saved_sym != NULL)
071436c6 11227 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11228 break;
11229 }
11230 break;
11231 }
11232
cf13d699
NC		 11233 case EM_MN10300:
11234 case EM_CYGNUS_MN10300:
11235 {
11236 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11237
cf13d699
NC		 11238 switch (reloc_type)
11239 {
11240 case 34: /* R_MN10300_ALIGN */
11241 return TRUE;
11242 case 33: /* R_MN10300_SYM_DIFF */
11243 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11244 return TRUE;
11245 case 1: /* R_MN10300_32 */
11246 case 2: /* R_MN10300_16 */
11247 if (saved_sym != NULL)
11248 {
11249 bfd_vma value;
252b5132 11250
cf13d699
NC		 11251 value = reloc->r_addend
11252 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11253 - saved_sym->st_value);
252b5132 11254
cf13d699 11255 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11256
cf13d699
NC		 11257 saved_sym = NULL;
11258 return TRUE;
11259 }
11260 break;
11261 default:
11262 if (saved_sym != NULL)
071436c6 11263 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11264 break;
11265 }
11266 break;
11267 }
6ff71e76
NC		 11268
11269 case EM_RL78:
11270 {
11271 static bfd_vma saved_sym1 = 0;
11272 static bfd_vma saved_sym2 = 0;
11273 static bfd_vma value;
11274
11275 switch (reloc_type)
11276 {
11277 case 0x80: /* R_RL78_SYM. */
11278 saved_sym1 = saved_sym2;
11279 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11280 saved_sym2 += reloc->r_addend;
11281 return TRUE;
11282
11283 case 0x83: /* R_RL78_OPsub. */
11284 value = saved_sym1 - saved_sym2;
11285 saved_sym2 = saved_sym1 = 0;
11286 return TRUE;
11287 break;
11288
11289 case 0x41: /* R_RL78_ABS32. */
11290 byte_put (start + reloc->r_offset, value, 4);
11291 value = 0;
11292 return TRUE;
11293
11294 case 0x43: /* R_RL78_ABS16. */
11295 byte_put (start + reloc->r_offset, value, 2);
11296 value = 0;
11297 return TRUE;
11298
11299 default:
11300 break;
11301 }
11302 break;
11303 }
252b5132
RH		 11304 }
11305
cf13d699 11306 return FALSE;
252b5132
RH		 11307}
11308
aca88567
NC		 11309/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11310 DWARF debug sections. This is a target specific test. Note - we do not
11311 go through the whole including-target-headers-multiple-times route, (as
11312 we have already done with <elf/h8.h>) because this would become very
11313 messy and even then this function would have to contain target specific
11314 information (the names of the relocs instead of their numeric values).
11315 FIXME: This is not the correct way to solve this problem. The proper way
11316 is to have target specific reloc sizing and typing functions created by
11317 the reloc-macros.h header, in the same way that it already creates the
11318 reloc naming functions. */
11319
11320static bfd_boolean
11321is_32bit_abs_reloc (unsigned int reloc_type)
11322{
11323 switch (elf_header.e_machine)
11324 {
41e92641 11325 case EM_386:
22abe556 11326 case EM_IAMCU:
41e92641 11327 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11328 case EM_68K:
11329 return reloc_type == 1; /* R_68K_32. */
11330 case EM_860:
11331 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11332 case EM_960:
11333 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11334 case EM_AARCH64:
11335 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11336 case EM_ALPHA:
137b6b5f 11337 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11338 case EM_ARC:
11339 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11340 case EM_ARC_COMPACT:
11341 case EM_ARC_COMPACT2:
11342 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11343 case EM_ARM:
11344 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11345 case EM_AVR_OLD:
aca88567
NC		 11346 case EM_AVR:
11347 return reloc_type == 1;
cfb8c092
NC		 11348 case EM_ADAPTEVA_EPIPHANY:
11349 return reloc_type == 3;
aca88567
NC		 11350 case EM_BLACKFIN:
11351 return reloc_type == 0x12; /* R_byte4_data. */
11352 case EM_CRIS:
11353 return reloc_type == 3; /* R_CRIS_32. */
11354 case EM_CR16:
11355 return reloc_type == 3; /* R_CR16_NUM32. */
11356 case EM_CRX:
11357 return reloc_type == 15; /* R_CRX_NUM32. */
11358 case EM_CYGNUS_FRV:
11359 return reloc_type == 1;
41e92641
NC		 11360 case EM_CYGNUS_D10V:
11361 case EM_D10V:
11362 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11363 case EM_CYGNUS_D30V:
11364 case EM_D30V:
11365 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11366 case EM_DLX:
11367 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11368 case EM_CYGNUS_FR30:
11369 case EM_FR30:
11370 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11371 case EM_FT32:
11372 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11373 case EM_H8S:
11374 case EM_H8_300:
11375 case EM_H8_300H:
11376 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11377 case EM_IA_64:
d1c4b12b
NC		 11378 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11379 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11380 case EM_IP2K_OLD:
11381 case EM_IP2K:
11382 return reloc_type == 2; /* R_IP2K_32. */
11383 case EM_IQ2000:
11384 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11385 case EM_LATTICEMICO32:
11386 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11387 case EM_M32C_OLD:
aca88567
NC		 11388 case EM_M32C:
11389 return reloc_type == 3; /* R_M32C_32. */
11390 case EM_M32R:
11391 return reloc_type == 34; /* R_M32R_32_RELA. */
11392 case EM_MCORE:
11393 return reloc_type == 1; /* R_MCORE_ADDR32. */
11394 case EM_CYGNUS_MEP:
11395 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11396 case EM_METAG:
11397 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11398 case EM_MICROBLAZE:
11399 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11400 case EM_MIPS:
11401 return reloc_type == 2; /* R_MIPS_32. */
11402 case EM_MMIX:
11403 return reloc_type == 4; /* R_MMIX_32. */
11404 case EM_CYGNUS_MN10200:
11405 case EM_MN10200:
11406 return reloc_type == 1; /* R_MN10200_32. */
11407 case EM_CYGNUS_MN10300:
11408 case EM_MN10300:
11409 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11410 case EM_MOXIE:
11411 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11412 case EM_MSP430_OLD:
11413 case EM_MSP430:
13761a11 11414 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11415 case EM_MT:
11416 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11417 case EM_NDS32:
11418 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11419 case EM_ALTERA_NIOS2:
36591ba1 11420 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11421 case EM_NIOS32:
11422 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11423 case EM_OR1K:
11424 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11425 case EM_PARISC:
5fda8eca
NC		 11426 return (reloc_type == 1 /* R_PARISC_DIR32. */
11427 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11428 case EM_PJ:
11429 case EM_PJ_OLD:
11430 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11431 case EM_PPC64:
11432 return reloc_type == 1; /* R_PPC64_ADDR32. */
11433 case EM_PPC:
11434 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11435 case EM_RL78:
11436 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11437 case EM_RX:
11438 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11439 case EM_S370:
11440 return reloc_type == 1; /* R_I370_ADDR31. */
11441 case EM_S390_OLD:
11442 case EM_S390:
11443 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11444 case EM_SCORE:
11445 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11446 case EM_SH:
11447 return reloc_type == 1; /* R_SH_DIR32. */
11448 case EM_SPARC32PLUS:
11449 case EM_SPARCV9:
11450 case EM_SPARC:
11451 return reloc_type == 3 /* R_SPARC_32. */
11452 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11453 case EM_SPU:
11454 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11455 case EM_TI_C6000:
11456 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11457 case EM_TILEGX:
11458 return reloc_type == 2; /* R_TILEGX_32. */
11459 case EM_TILEPRO:
11460 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11461 case EM_CYGNUS_V850:
11462 case EM_V850:
11463 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11464 case EM_V800:
11465 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11466 case EM_VAX:
11467 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11468 case EM_VISIUM:
11469 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11470 case EM_X86_64:
8a9036a4 11471 case EM_L1OM:
7a9068fe 11472 case EM_K1OM:
aca88567 11473 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11474 case EM_XC16X:
11475 case EM_C166:
11476 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11477 case EM_XGATE:
11478 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11479 case EM_XSTORMY16:
11480 return reloc_type == 1; /* R_XSTROMY16_32. */
11481 case EM_XTENSA_OLD:
11482 case EM_XTENSA:
11483 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11484 default:
bee0ee85
NC		 11485 {
11486 static unsigned int prev_warn = 0;
11487
11488 /* Avoid repeating the same warning multiple times. */
11489 if (prev_warn != elf_header.e_machine)
11490 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11491 elf_header.e_machine);
11492 prev_warn = elf_header.e_machine;
11493 return FALSE;
11494 }
aca88567
NC		 11495 }
11496}
11497
11498/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11499 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11500
11501static bfd_boolean
11502is_32bit_pcrel_reloc (unsigned int reloc_type)
11503{
11504 switch (elf_header.e_machine)
11505 {
41e92641 11506 case EM_386:
22abe556 11507 case EM_IAMCU:
3e0873ac 11508 return reloc_type == 2; /* R_386_PC32. */
aca88567 11509 case EM_68K:
3e0873ac 11510 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11511 case EM_AARCH64:
11512 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11513 case EM_ADAPTEVA_EPIPHANY:
11514 return reloc_type == 6;
aca88567
NC		 11515 case EM_ALPHA:
11516 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11517 case EM_ARM:
3e0873ac 11518 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11519 case EM_MICROBLAZE:
11520 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11521 case EM_OR1K:
11522 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11523 case EM_PARISC:
85acf597 11524 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11525 case EM_PPC:
11526 return reloc_type == 26; /* R_PPC_REL32. */
11527 case EM_PPC64:
3e0873ac 11528 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11529 case EM_S390_OLD:
11530 case EM_S390:
3e0873ac 11531 return reloc_type == 5; /* R_390_PC32. */
aca88567 11532 case EM_SH:
3e0873ac 11533 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11534 case EM_SPARC32PLUS:
11535 case EM_SPARCV9:
11536 case EM_SPARC:
3e0873ac 11537 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11538 case EM_SPU:
11539 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11540 case EM_TILEGX:
11541 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11542 case EM_TILEPRO:
11543 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11544 case EM_VISIUM:
11545 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11546 case EM_X86_64:
8a9036a4 11547 case EM_L1OM:
7a9068fe 11548 case EM_K1OM:
3e0873ac 11549 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11550 case EM_XTENSA_OLD:
11551 case EM_XTENSA:
11552 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11553 default:
11554 /* Do not abort or issue an error message here. Not all targets use
11555 pc-relative 32-bit relocs in their DWARF debug information and we
11556 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11557 more helpful warning message will be generated by apply_relocations
11558 anyway, so just return. */
aca88567
NC		 11559 return FALSE;
11560 }
11561}
11562
11563/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11564 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11565
11566static bfd_boolean
11567is_64bit_abs_reloc (unsigned int reloc_type)
11568{
11569 switch (elf_header.e_machine)
11570 {
a06ea964
NC		 11571 case EM_AARCH64:
11572 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11573 case EM_ALPHA:
11574 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11575 case EM_IA_64:
11576 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11577 case EM_PARISC:
11578 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11579 case EM_PPC64:
11580 return reloc_type == 38; /* R_PPC64_ADDR64. */
11581 case EM_SPARC32PLUS:
11582 case EM_SPARCV9:
11583 case EM_SPARC:
11584 return reloc_type == 54; /* R_SPARC_UA64. */
11585 case EM_X86_64:
8a9036a4 11586 case EM_L1OM:
7a9068fe 11587 case EM_K1OM:
aca88567 11588 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11589 case EM_S390_OLD:
11590 case EM_S390:
aa137e4d
NC		 11591 return reloc_type == 22; /* R_S390_64. */
11592 case EM_TILEGX:
11593 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11594 case EM_MIPS:
aa137e4d 11595 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11596 default:
11597 return FALSE;
11598 }
11599}
11600
85acf597
RH		 11601/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11602 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11603
11604static bfd_boolean
11605is_64bit_pcrel_reloc (unsigned int reloc_type)
11606{
11607 switch (elf_header.e_machine)
11608 {
a06ea964
NC		 11609 case EM_AARCH64:
11610 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11611 case EM_ALPHA:
aa137e4d 11612 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11613 case EM_IA_64:
aa137e4d 11614 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11615 case EM_PARISC:
aa137e4d 11616 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11617 case EM_PPC64:
aa137e4d 11618 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11619 case EM_SPARC32PLUS:
11620 case EM_SPARCV9:
11621 case EM_SPARC:
aa137e4d 11622 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11623 case EM_X86_64:
8a9036a4 11624 case EM_L1OM:
7a9068fe 11625 case EM_K1OM:
aa137e4d 11626 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11627 case EM_S390_OLD:
11628 case EM_S390:
aa137e4d
NC		 11629 return reloc_type == 23; /* R_S390_PC64. */
11630 case EM_TILEGX:
11631 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11632 default:
11633 return FALSE;
11634 }
11635}
11636
4dc3c23d
AM		 11637/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11638 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11639
11640static bfd_boolean
11641is_24bit_abs_reloc (unsigned int reloc_type)
11642{
11643 switch (elf_header.e_machine)
11644 {
11645 case EM_CYGNUS_MN10200:
11646 case EM_MN10200:
11647 return reloc_type == 4; /* R_MN10200_24. */
11648 default:
11649 return FALSE;
11650 }
11651}
11652
aca88567
NC		 11653/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11654 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11655
11656static bfd_boolean
11657is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11658{
11659 switch (elf_header.e_machine)
11660 {
886a2506
NC		 11661 case EM_ARC:
11662 case EM_ARC_COMPACT:
11663 case EM_ARC_COMPACT2:
11664 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11665 case EM_AVR_OLD:
11666 case EM_AVR:
11667 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11668 case EM_ADAPTEVA_EPIPHANY:
11669 return reloc_type == 5;
41e92641
NC		 11670 case EM_CYGNUS_D10V:
11671 case EM_D10V:
11672 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11673 case EM_H8S:
11674 case EM_H8_300:
11675 case EM_H8_300H:
aca88567
NC		 11676 return reloc_type == R_H8_DIR16;
11677 case EM_IP2K_OLD:
11678 case EM_IP2K:
11679 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11680 case EM_M32C_OLD:
f4236fe4
DD		 11681 case EM_M32C:
11682 return reloc_type == 1; /* R_M32C_16 */
aca88567 11683 case EM_MSP430:
13761a11
NC		 11684 if (uses_msp430x_relocs ())
11685 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11686 case EM_MSP430_OLD:
aca88567 11687 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11688 case EM_NDS32:
11689 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11690 case EM_ALTERA_NIOS2:
36591ba1 11691 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11692 case EM_NIOS32:
11693 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11694 case EM_OR1K:
11695 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11696 case EM_TI_C6000:
11697 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11698 case EM_XC16X:
11699 case EM_C166:
11700 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11701 case EM_CYGNUS_MN10200:
11702 case EM_MN10200:
11703 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11704 case EM_CYGNUS_MN10300:
11705 case EM_MN10300:
11706 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11707 case EM_VISIUM:
11708 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11709 case EM_XGATE:
11710 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11711 default:
aca88567 11712 return FALSE;
4b78141a
NC		 11713 }
11714}
11715
2a7b2e88
JK		 11716/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11717 relocation entries (possibly formerly used for SHT_GROUP sections). */
11718
11719static bfd_boolean
11720is_none_reloc (unsigned int reloc_type)
11721{
11722 switch (elf_header.e_machine)
11723 {
cb8f3167
NC		 11724 case EM_68K: /* R_68K_NONE. */
11725 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11726 case EM_SPARC32PLUS:
11727 case EM_SPARCV9:
cb8f3167
NC		 11728 case EM_SPARC: /* R_SPARC_NONE. */
11729 case EM_MIPS: /* R_MIPS_NONE. */
11730 case EM_PARISC: /* R_PARISC_NONE. */
11731 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11732 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11733 case EM_PPC: /* R_PPC_NONE. */
11734 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11735 case EM_ARC: /* R_ARC_NONE. */
11736 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11737 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11738 case EM_ARM: /* R_ARM_NONE. */
11739 case EM_IA_64: /* R_IA64_NONE. */
11740 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11741 case EM_S390_OLD:
cb8f3167
NC		 11742 case EM_S390: /* R_390_NONE. */
11743 case EM_CRIS: /* R_CRIS_NONE. */
11744 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11745 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11746 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11747 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11748 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11749 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11750 case EM_M32R: /* R_M32R_NONE. */
40b36596 11751 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11752 case EM_TILEGX: /* R_TILEGX_NONE. */
11753 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11754 case EM_XC16X:
11755 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11756 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11757 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11758 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11759 return reloc_type == 0;
a06ea964
NC		 11760 case EM_AARCH64:
11761 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11762 case EM_NDS32:
11763 return (reloc_type == 0 /* R_XTENSA_NONE. */
11764 || reloc_type == 204 /* R_NDS32_DIFF8. */
11765 || reloc_type == 205 /* R_NDS32_DIFF16. */
11766 || reloc_type == 206 /* R_NDS32_DIFF32. */
11767 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11768 case EM_XTENSA_OLD:
11769 case EM_XTENSA:
4dc3c23d
AM		 11770 return (reloc_type == 0 /* R_XTENSA_NONE. */
11771 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11772 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11773 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11774 case EM_METAG:
11775 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11776 }
11777 return FALSE;
11778}
11779
d1c4b12b
NC		 11780/* Returns TRUE if there is a relocation against
11781 section NAME at OFFSET bytes. */
11782
11783bfd_boolean
11784reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11785{
11786 Elf_Internal_Rela * relocs;
11787 Elf_Internal_Rela * rp;
11788
11789 if (dsec == NULL || dsec->reloc_info == NULL)
11790 return FALSE;
11791
11792 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11793
11794 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11795 if (rp->r_offset == offset)
11796 return TRUE;
11797
11798 return FALSE;
11799}
11800
cf13d699
NC		 11801/* Apply relocations to a section.
11802 Note: So far support has been added only for those relocations
11803 which can be found in debug sections.
d1c4b12b
NC		 11804 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11805 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11806 FIXME: Add support for more relocations ? */
1b315056 11807
cf13d699 11808static void
d1c4b12b
NC		 11809apply_relocations (void * file,
11810 const Elf_Internal_Shdr * section,
11811 unsigned char * start,
11812 bfd_size_type size,
11813 void ** relocs_return,
11814 unsigned long * num_relocs_return)
1b315056 11815{
cf13d699 11816 Elf_Internal_Shdr * relsec;
0d2a7a93 11817 unsigned char * end = start + size;
cb8f3167 11818
d1c4b12b
NC		 11819 if (relocs_return != NULL)
11820 {
11821 * (Elf_Internal_Rela **) relocs_return = NULL;
11822 * num_relocs_return = 0;
11823 }
11824
cf13d699
NC		 11825 if (elf_header.e_type != ET_REL)
11826 return;
1b315056 11827
cf13d699 11828 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11829 for (relsec = section_headers;
11830 relsec < section_headers + elf_header.e_shnum;
11831 ++relsec)
252b5132 11832 {
41e92641
NC		 11833 bfd_boolean is_rela;
11834 unsigned long num_relocs;
2cf0635d
NC		 11835 Elf_Internal_Rela * relocs;
11836 Elf_Internal_Rela * rp;
11837 Elf_Internal_Shdr * symsec;
11838 Elf_Internal_Sym * symtab;
ba5cdace 11839 unsigned long num_syms;
2cf0635d 11840 Elf_Internal_Sym * sym;
252b5132 11841
41e92641 11842 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11843 || relsec->sh_info >= elf_header.e_shnum
11844 || section_headers + relsec->sh_info != section
c256ffe7 11845 || relsec->sh_size == 0
4fbb74a6 11846 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11847 continue;
428409d5 11848
41e92641
NC		 11849 is_rela = relsec->sh_type == SHT_RELA;
11850
11851 if (is_rela)
11852 {
3f5e193b
NC		 11853 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11854 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11855 return;
11856 }
11857 else
11858 {
3f5e193b
NC		 11859 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11860 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11861 return;
11862 }
11863
11864 /* SH uses RELA but uses in place value instead of the addend field. */
11865 if (elf_header.e_machine == EM_SH)
11866 is_rela = FALSE;
428409d5 11867
4fbb74a6 11868 symsec = section_headers + relsec->sh_link;
ba5cdace 11869 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11870
41e92641 11871 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11872 {
41e92641
NC		 11873 bfd_vma addend;
11874 unsigned int reloc_type;
11875 unsigned int reloc_size;
91d6fa6a 11876 unsigned char * rloc;
ba5cdace 11877 unsigned long sym_index;
4b78141a 11878
aca88567 11879 reloc_type = get_reloc_type (rp->r_info);
41e92641 11880
98fb390a 11881 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11882 continue;
98fb390a
NC		 11883 else if (is_none_reloc (reloc_type))
11884 continue;
11885 else if (is_32bit_abs_reloc (reloc_type)
11886 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11887 reloc_size = 4;
85acf597
RH		 11888 else if (is_64bit_abs_reloc (reloc_type)
11889 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11890 reloc_size = 8;
4dc3c23d
AM		 11891 else if (is_24bit_abs_reloc (reloc_type))
11892 reloc_size = 3;
aca88567
NC		 11893 else if (is_16bit_abs_reloc (reloc_type))
11894 reloc_size = 2;
11895 else
4b78141a 11896 {
bee0ee85
NC		 11897 static unsigned int prev_reloc = 0;
11898 if (reloc_type != prev_reloc)
11899 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11900 reloc_type, printable_section_name (section));
11901 prev_reloc = reloc_type;
4b78141a
NC		 11902 continue;
11903 }
103f02d3 11904
91d6fa6a 11905 rloc = start + rp->r_offset;
c8da6823 11906 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11907 {
11908 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11909 (unsigned long) rp->r_offset,
74e1a04b 11910 printable_section_name (section));
700dd8b7
L		 11911 continue;
11912 }
103f02d3 11913
ba5cdace
NC		 11914 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11915 if (sym_index >= num_syms)
11916 {
11917 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11918 sym_index, printable_section_name (section));
ba5cdace
NC		 11919 continue;
11920 }
11921 sym = symtab + sym_index;
41e92641
NC		 11922
11923 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11924 make sure that it is of an appropriate type.
11925
11926 Relocations against symbols without type can happen.
11927 Gcc -feliminate-dwarf2-dups may generate symbols
11928 without type for debug info.
11929
11930 Icc generates relocations against function symbols
11931 instead of local labels.
11932
11933 Relocations against object symbols can happen, eg when
11934 referencing a global array. For an example of this see
11935 the _clz.o binary in libgcc.a. */
aca88567 11936 if (sym != symtab
55f25fc3 11937 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11938 {
41e92641 11939 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11940 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11941 (long int)(rp - relocs),
74e1a04b 11942 printable_section_name (relsec));
aca88567 11943 continue;
5b18a4bc 11944 }
252b5132 11945
4dc3c23d
AM		 11946 addend = 0;
11947 if (is_rela)
11948 addend += rp->r_addend;
c47320c3
AM		 11949 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11950 partial_inplace. */
4dc3c23d
AM		 11951 if (!is_rela
11952 || (elf_header.e_machine == EM_XTENSA
11953 && reloc_type == 1)
11954 || ((elf_header.e_machine == EM_PJ
11955 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11956 && reloc_type == 1)
11957 || ((elf_header.e_machine == EM_D30V
11958 || elf_header.e_machine == EM_CYGNUS_D30V)
11959 && reloc_type == 12))
91d6fa6a 11960 addend += byte_get (rloc, reloc_size);
cb8f3167 11961
85acf597
RH		 11962 if (is_32bit_pcrel_reloc (reloc_type)
11963 || is_64bit_pcrel_reloc (reloc_type))
11964 {
11965 /* On HPPA, all pc-relative relocations are biased by 8. */
11966 if (elf_header.e_machine == EM_PARISC)
11967 addend -= 8;
91d6fa6a 11968 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11969 reloc_size);
11970 }
41e92641 11971 else
91d6fa6a 11972 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 11973 }
252b5132 11974
5b18a4bc 11975 free (symtab);
d1c4b12b
NC		 11976
11977 if (relocs_return)
11978 {
11979 * (Elf_Internal_Rela **) relocs_return = relocs;
11980 * num_relocs_return = num_relocs;
11981 }
11982 else
11983 free (relocs);
11984
5b18a4bc
NC		 11985 break;
11986 }
5b18a4bc 11987}
103f02d3 11988
cf13d699
NC		 11989#ifdef SUPPORT_DISASSEMBLY
11990static int
11991disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11992{
74e1a04b 11993 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 11994
74e1a04b 11995 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 11996
11997 return 1;
11998}
11999#endif
12000
12001/* Reads in the contents of SECTION from FILE, returning a pointer
12002 to a malloc'ed buffer or NULL if something went wrong. */
12003
12004static char *
12005get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12006{
12007 bfd_size_type num_bytes;
12008
12009 num_bytes = section->sh_size;
12010
12011 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12012 {
12013 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12014 printable_section_name (section));
cf13d699
NC		 12015 return NULL;
12016 }
12017
3f5e193b
NC		 12018 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12019 _("section contents"));
cf13d699
NC		 12020}
12021
0e602686
NC		 12022/* Uncompresses a section that was compressed using zlib, in place. */
12023
12024static bfd_boolean
12025uncompress_section_contents (unsigned char **buffer,
12026 dwarf_size_type uncompressed_size,
12027 dwarf_size_type *size)
12028{
12029 dwarf_size_type compressed_size = *size;
12030 unsigned char * compressed_buffer = *buffer;
12031 unsigned char * uncompressed_buffer;
12032 z_stream strm;
12033 int rc;
12034
12035 /* It is possible the section consists of several compressed
12036 buffers concatenated together, so we uncompress in a loop. */
12037 /* PR 18313: The state field in the z_stream structure is supposed
12038 to be invisible to the user (ie us), but some compilers will
12039 still complain about it being used without initialisation. So
12040 we first zero the entire z_stream structure and then set the fields
12041 that we need. */
12042 memset (& strm, 0, sizeof strm);
12043 strm.avail_in = compressed_size;
12044 strm.next_in = (Bytef *) compressed_buffer;
12045 strm.avail_out = uncompressed_size;
12046 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12047
12048 rc = inflateInit (& strm);
12049 while (strm.avail_in > 0)
12050 {
12051 if (rc != Z_OK)
12052 goto fail;
12053 strm.next_out = ((Bytef *) uncompressed_buffer
12054 + (uncompressed_size - strm.avail_out));
12055 rc = inflate (&strm, Z_FINISH);
12056 if (rc != Z_STREAM_END)
12057 goto fail;
12058 rc = inflateReset (& strm);
12059 }
12060 rc = inflateEnd (& strm);
12061 if (rc != Z_OK
12062 || strm.avail_out != 0)
12063 goto fail;
12064
12065 *buffer = uncompressed_buffer;
12066 *size = uncompressed_size;
12067 return TRUE;
12068
12069 fail:
12070 free (uncompressed_buffer);
12071 /* Indicate decompression failure. */
12072 *buffer = NULL;
12073 return FALSE;
12074}
dd24e3da 12075
cf13d699
NC		 12076static void
12077dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12078{
0e602686
NC		 12079 Elf_Internal_Shdr * relsec;
12080 bfd_size_type num_bytes;
fd8008d8
L		 12081 unsigned char * data;
12082 unsigned char * end;
12083 unsigned char * real_start;
12084 unsigned char * start;
0e602686 12085 bfd_boolean some_strings_shown;
cf13d699 12086
fd8008d8
L		 12087 real_start = start = (unsigned char *) get_section_contents (section,
12088 file);
cf13d699
NC		 12089 if (start == NULL)
12090 return;
0e602686 12091 num_bytes = section->sh_size;
cf13d699 12092
74e1a04b 12093 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12094
0e602686
NC		 12095 if (decompress_dumps)
12096 {
12097 dwarf_size_type new_size = num_bytes;
12098 dwarf_size_type uncompressed_size = 0;
12099
12100 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12101 {
12102 Elf_Internal_Chdr chdr;
12103 unsigned int compression_header_size
12104 = get_compression_header (& chdr, (unsigned char *) start);
12105
813dabb9 12106 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12107 {
813dabb9
L		 12108 warn (_("section '%s' has unsupported compress type: %d\n"),
12109 printable_section_name (section), chdr.ch_type);
12110 return;
12111 }
12112 else if (chdr.ch_addralign != section->sh_addralign)
12113 {
12114 warn (_("compressed section '%s' is corrupted\n"),
12115 printable_section_name (section));
12116 return;
0e602686 12117 }
813dabb9
L		 12118 uncompressed_size = chdr.ch_size;
12119 start += compression_header_size;
12120 new_size -= compression_header_size;
0e602686
NC		 12121 }
12122 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12123 {
12124 /* Read the zlib header. In this case, it should be "ZLIB"
12125 followed by the uncompressed section size, 8 bytes in
12126 big-endian order. */
12127 uncompressed_size = start[4]; uncompressed_size <<= 8;
12128 uncompressed_size += start[5]; uncompressed_size <<= 8;
12129 uncompressed_size += start[6]; uncompressed_size <<= 8;
12130 uncompressed_size += start[7]; uncompressed_size <<= 8;
12131 uncompressed_size += start[8]; uncompressed_size <<= 8;
12132 uncompressed_size += start[9]; uncompressed_size <<= 8;
12133 uncompressed_size += start[10]; uncompressed_size <<= 8;
12134 uncompressed_size += start[11];
12135 start += 12;
12136 new_size -= 12;
12137 }
12138
12139 if (uncompressed_size
fd8008d8 12140 && uncompress_section_contents (& start,
0e602686
NC		 12141 uncompressed_size, & new_size))
12142 num_bytes = new_size;
12143 }
fd8008d8 12144
cf13d699
NC		 12145 /* If the section being dumped has relocations against it the user might
12146 be expecting these relocations to have been applied. Check for this
12147 case and issue a warning message in order to avoid confusion.
12148 FIXME: Maybe we ought to have an option that dumps a section with
12149 relocs applied ? */
12150 for (relsec = section_headers;
12151 relsec < section_headers + elf_header.e_shnum;
12152 ++relsec)
12153 {
12154 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12155 || relsec->sh_info >= elf_header.e_shnum
12156 || section_headers + relsec->sh_info != section
12157 || relsec->sh_size == 0
12158 || relsec->sh_link >= elf_header.e_shnum)
12159 continue;
12160
12161 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12162 break;
12163 }
12164
cf13d699
NC		 12165 data = start;
12166 end = start + num_bytes;
12167 some_strings_shown = FALSE;
12168
12169 while (data < end)
12170 {
12171 while (!ISPRINT (* data))
12172 if (++ data >= end)
12173 break;
12174
12175 if (data < end)
12176 {
071436c6
NC		 12177 size_t maxlen = end - data;
12178
cf13d699 12179#ifndef __MSVCRT__
c975cc98
NC		 12180 /* PR 11128: Use two separate invocations in order to work
12181 around bugs in the Solaris 8 implementation of printf. */
12182 printf (" [%6tx] ", data - start);
cf13d699 12183#else
071436c6 12184 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12185#endif
4082ef84
NC		 12186 if (maxlen > 0)
12187 {
fd8008d8 12188 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12189 putchar ('\n');
fd8008d8 12190 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12191 }
12192 else
12193 {
12194 printf (_("<corrupt>\n"));
12195 data = end;
12196 }
cf13d699
NC		 12197 some_strings_shown = TRUE;
12198 }
12199 }
12200
12201 if (! some_strings_shown)
12202 printf (_(" No strings found in this section."));
12203
0e602686 12204 free (real_start);
cf13d699
NC		 12205
12206 putchar ('\n');
12207}
12208
12209static void
12210dump_section_as_bytes (Elf_Internal_Shdr * section,
12211 FILE * file,
12212 bfd_boolean relocate)
12213{
12214 Elf_Internal_Shdr * relsec;
0e602686
NC		 12215 bfd_size_type bytes;
12216 bfd_size_type section_size;
12217 bfd_vma addr;
12218 unsigned char * data;
12219 unsigned char * real_start;
12220 unsigned char * start;
12221
12222 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12223 if (start == NULL)
12224 return;
0e602686 12225 section_size = section->sh_size;
cf13d699 12226
74e1a04b 12227 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12228
0e602686
NC		 12229 if (decompress_dumps)
12230 {
12231 dwarf_size_type new_size = section_size;
12232 dwarf_size_type uncompressed_size = 0;
12233
12234 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12235 {
12236 Elf_Internal_Chdr chdr;
12237 unsigned int compression_header_size
12238 = get_compression_header (& chdr, start);
12239
813dabb9 12240 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12241 {
813dabb9
L		 12242 warn (_("section '%s' has unsupported compress type: %d\n"),
12243 printable_section_name (section), chdr.ch_type);
12244 return;
0e602686 12245 }
813dabb9
L		 12246 else if (chdr.ch_addralign != section->sh_addralign)
12247 {
12248 warn (_("compressed section '%s' is corrupted\n"),
12249 printable_section_name (section));
12250 return;
12251 }
12252 uncompressed_size = chdr.ch_size;
12253 start += compression_header_size;
12254 new_size -= compression_header_size;
0e602686
NC		 12255 }
12256 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12257 {
12258 /* Read the zlib header. In this case, it should be "ZLIB"
12259 followed by the uncompressed section size, 8 bytes in
12260 big-endian order. */
12261 uncompressed_size = start[4]; uncompressed_size <<= 8;
12262 uncompressed_size += start[5]; uncompressed_size <<= 8;
12263 uncompressed_size += start[6]; uncompressed_size <<= 8;
12264 uncompressed_size += start[7]; uncompressed_size <<= 8;
12265 uncompressed_size += start[8]; uncompressed_size <<= 8;
12266 uncompressed_size += start[9]; uncompressed_size <<= 8;
12267 uncompressed_size += start[10]; uncompressed_size <<= 8;
12268 uncompressed_size += start[11];
12269 start += 12;
12270 new_size -= 12;
12271 }
12272
12273 if (uncompressed_size
12274 && uncompress_section_contents (& start, uncompressed_size,
12275 & new_size))
12276 section_size = new_size;
12277 }
14ae95f2 12278
cf13d699
NC		 12279 if (relocate)
12280 {
0e602686 12281 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12282 }
12283 else
12284 {
12285 /* If the section being dumped has relocations against it the user might
12286 be expecting these relocations to have been applied. Check for this
12287 case and issue a warning message in order to avoid confusion.
12288 FIXME: Maybe we ought to have an option that dumps a section with
12289 relocs applied ? */
12290 for (relsec = section_headers;
12291 relsec < section_headers + elf_header.e_shnum;
12292 ++relsec)
12293 {
12294 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12295 || relsec->sh_info >= elf_header.e_shnum
12296 || section_headers + relsec->sh_info != section
12297 || relsec->sh_size == 0
12298 || relsec->sh_link >= elf_header.e_shnum)
12299 continue;
12300
12301 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12302 break;
12303 }
12304 }
12305
12306 addr = section->sh_addr;
0e602686 12307 bytes = section_size;
cf13d699
NC		 12308 data = start;
12309
12310 while (bytes)
12311 {
12312 int j;
12313 int k;
12314 int lbytes;
12315
12316 lbytes = (bytes > 16 ? 16 : bytes);
12317
12318 printf (" 0x%8.8lx ", (unsigned long) addr);
12319
12320 for (j = 0; j < 16; j++)
12321 {
12322 if (j < lbytes)
12323 printf ("%2.2x", data[j]);
12324 else
12325 printf (" ");
12326
12327 if ((j & 3) == 3)
12328 printf (" ");
12329 }
12330
12331 for (j = 0; j < lbytes; j++)
12332 {
12333 k = data[j];
12334 if (k >= ' ' && k < 0x7f)
12335 printf ("%c", k);
12336 else
12337 printf (".");
12338 }
12339
12340 putchar ('\n');
12341
12342 data += lbytes;
12343 addr += lbytes;
12344 bytes -= lbytes;
12345 }
12346
0e602686 12347 free (real_start);
cf13d699
NC		 12348
12349 putchar ('\n');
12350}
12351
d966045b
DJ		 12352static int
12353load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12354 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12355{
2cf0635d 12356 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12357 char buf [64];
1007acb3 12358
19e6b90e
L		 12359 /* If it is already loaded, do nothing. */
12360 if (section->start != NULL)
12361 return 1;
1007acb3 12362
19e6b90e
L		 12363 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12364 section->address = sec->sh_addr;
06614111 12365 section->user_data = NULL;
3f5e193b
NC		 12366 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12367 sec->sh_offset, 1,
12368 sec->sh_size, buf);
59245841
NC		 12369 if (section->start == NULL)
12370 section->size = 0;
12371 else
12372 {
77115a4a
L		 12373 unsigned char *start = section->start;
12374 dwarf_size_type size = sec->sh_size;
dab394de 12375 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12376
12377 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12378 {
12379 Elf_Internal_Chdr chdr;
12380 unsigned int compression_header_size
12381 = get_compression_header (&chdr, start);
813dabb9
L		 12382 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12383 {
12384 warn (_("section '%s' has unsupported compress type: %d\n"),
12385 section->name, chdr.ch_type);
12386 return 0;
12387 }
12388 else if (chdr.ch_addralign != sec->sh_addralign)
12389 {
12390 warn (_("compressed section '%s' is corrupted\n"),
12391 section->name);
12392 return 0;
12393 }
dab394de 12394 uncompressed_size = chdr.ch_size;
77115a4a
L		 12395 start += compression_header_size;
12396 size -= compression_header_size;
12397 }
dab394de
L		 12398 else if (size > 12 && streq ((char *) start, "ZLIB"))
12399 {
12400 /* Read the zlib header. In this case, it should be "ZLIB"
12401 followed by the uncompressed section size, 8 bytes in
12402 big-endian order. */
12403 uncompressed_size = start[4]; uncompressed_size <<= 8;
12404 uncompressed_size += start[5]; uncompressed_size <<= 8;
12405 uncompressed_size += start[6]; uncompressed_size <<= 8;
12406 uncompressed_size += start[7]; uncompressed_size <<= 8;
12407 uncompressed_size += start[8]; uncompressed_size <<= 8;
12408 uncompressed_size += start[9]; uncompressed_size <<= 8;
12409 uncompressed_size += start[10]; uncompressed_size <<= 8;
12410 uncompressed_size += start[11];
12411 start += 12;
12412 size -= 12;
12413 }
12414
12415 if (uncompressed_size
12416 && uncompress_section_contents (&start, uncompressed_size,
12417 &size))
77115a4a
L		 12418 {
12419 /* Free the compressed buffer, update the section buffer
12420 and the section size if uncompress is successful. */
12421 free (section->start);
12422 section->start = start;
77115a4a
L		 12423 }
12424 section->size = size;
59245841 12425 }
4a114e3e 12426
1b315056
CS		 12427 if (section->start == NULL)
12428 return 0;
12429
19e6b90e 12430 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12431 apply_relocations ((FILE *) file, sec, section->start, section->size,
12432 & section->reloc_info, & section->num_relocs);
12433 else
12434 {
12435 section->reloc_info = NULL;
12436 section->num_relocs = 0;
12437 }
1007acb3 12438
1b315056 12439 return 1;
1007acb3
L		 12440}
12441
657d0d47
CC		 12442/* If this is not NULL, load_debug_section will only look for sections
12443 within the list of sections given here. */
12444unsigned int *section_subset = NULL;
12445
d966045b 12446int
2cf0635d 12447load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12448{
2cf0635d
NC		 12449 struct dwarf_section * section = &debug_displays [debug].section;
12450 Elf_Internal_Shdr * sec;
d966045b
DJ		 12451
12452 /* Locate the debug section. */
657d0d47 12453 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12454 if (sec != NULL)
12455 section->name = section->uncompressed_name;
12456 else
12457 {
657d0d47 12458 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12459 if (sec != NULL)
12460 section->name = section->compressed_name;
12461 }
12462 if (sec == NULL)
12463 return 0;
12464
657d0d47
CC		 12465 /* If we're loading from a subset of sections, and we've loaded
12466 a section matching this name before, it's likely that it's a
12467 different one. */
12468 if (section_subset != NULL)
12469 free_debug_section (debug);
12470
3f5e193b 12471 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12472}
12473
19e6b90e
L		 12474void
12475free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12476{
2cf0635d 12477 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12478
19e6b90e
L		 12479 if (section->start == NULL)
12480 return;
1007acb3 12481
19e6b90e
L		 12482 free ((char *) section->start);
12483 section->start = NULL;
12484 section->address = 0;
12485 section->size = 0;
1007acb3
L		 12486}
12487
1007acb3 12488static int
657d0d47 12489display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12490{
2cf0635d 12491 char * name = SECTION_NAME (section);
74e1a04b 12492 const char * print_name = printable_section_name (section);
19e6b90e
L		 12493 bfd_size_type length;
12494 int result = 1;
3f5e193b 12495 int i;
1007acb3 12496
19e6b90e
L		 12497 length = section->sh_size;
12498 if (length == 0)
1007acb3 12499 {
74e1a04b 12500 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12501 return 0;
1007acb3 12502 }
5dff79d8
NC		 12503 if (section->sh_type == SHT_NOBITS)
12504 {
12505 /* There is no point in dumping the contents of a debugging section
12506 which has the NOBITS type - the bits in the file will be random.
12507 This can happen when a file containing a .eh_frame section is
12508 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12509 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12510 print_name);
5dff79d8
NC		 12511 return 0;
12512 }
1007acb3 12513
0112cd26 12514 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12515 name = ".debug_info";
1007acb3 12516
19e6b90e
L		 12517 /* See if we know how to display the contents of this section. */
12518 for (i = 0; i < max; i++)
1b315056 12519 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12520 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12521 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12522 {
2cf0635d 12523 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12524 int secondary = (section != find_section (name));
12525
12526 if (secondary)
3f5e193b 12527 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12528
b40bf0a2
NC		 12529 if (i == line && const_strneq (name, ".debug_line."))
12530 sec->name = name;
12531 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12532 sec->name = sec->uncompressed_name;
12533 else
12534 sec->name = sec->compressed_name;
3f5e193b
NC		 12535 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12536 section, file))
19e6b90e 12537 {
657d0d47
CC		 12538 /* If this debug section is part of a CU/TU set in a .dwp file,
12539 restrict load_debug_section to the sections in that set. */
12540 section_subset = find_cu_tu_set (file, shndx);
12541
19e6b90e 12542 result &= debug_displays[i].display (sec, file);
1007acb3 12543
657d0d47
CC		 12544 section_subset = NULL;
12545
d966045b 12546 if (secondary || (i != info && i != abbrev))
3f5e193b 12547 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12548 }
1007acb3 12549
19e6b90e
L		 12550 break;
12551 }
1007acb3 12552
19e6b90e 12553 if (i == max)
1007acb3 12554 {
74e1a04b 12555 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12556 result = 0;
1007acb3
L		 12557 }
12558
19e6b90e 12559 return result;
5b18a4bc 12560}
103f02d3 12561
aef1f6d0
DJ		 12562/* Set DUMP_SECTS for all sections where dumps were requested
12563 based on section name. */
12564
12565static void
12566initialise_dumps_byname (void)
12567{
2cf0635d 12568 struct dump_list_entry * cur;
aef1f6d0
DJ		 12569
12570 for (cur = dump_sects_byname; cur; cur = cur->next)
12571 {
12572 unsigned int i;
12573 int any;
12574
12575 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12576 if (streq (SECTION_NAME (section_headers + i), cur->name))
12577 {
09c11c86 12578 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12579 any = 1;
12580 }
12581
12582 if (!any)
12583 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12584 cur->name);
12585 }
12586}
12587
5b18a4bc 12588static void
2cf0635d 12589process_section_contents (FILE * file)
5b18a4bc 12590{
2cf0635d 12591 Elf_Internal_Shdr * section;
19e6b90e 12592 unsigned int i;
103f02d3 12593
19e6b90e
L		 12594 if (! do_dump)
12595 return;
103f02d3 12596
aef1f6d0
DJ		 12597 initialise_dumps_byname ();
12598
19e6b90e
L		 12599 for (i = 0, section = section_headers;
12600 i < elf_header.e_shnum && i < num_dump_sects;
12601 i++, section++)
12602 {
12603#ifdef SUPPORT_DISASSEMBLY
12604 if (dump_sects[i] & DISASS_DUMP)
12605 disassemble_section (section, file);
12606#endif
12607 if (dump_sects[i] & HEX_DUMP)
cf13d699 12608 dump_section_as_bytes (section, file, FALSE);
103f02d3 12609
cf13d699
NC		 12610 if (dump_sects[i] & RELOC_DUMP)
12611 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12612
12613 if (dump_sects[i] & STRING_DUMP)
12614 dump_section_as_strings (section, file);
cf13d699
NC		 12615
12616 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12617 display_debug_section (i, section, file);
5b18a4bc 12618 }
103f02d3 12619
19e6b90e
L		 12620 /* Check to see if the user requested a
12621 dump of a section that does not exist. */
12622 while (i++ < num_dump_sects)
12623 if (dump_sects[i])
12624 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12625}
103f02d3 12626
5b18a4bc 12627static void
19e6b90e 12628process_mips_fpe_exception (int mask)
5b18a4bc 12629{
19e6b90e
L		 12630 if (mask)
12631 {
12632 int first = 1;
12633 if (mask & OEX_FPU_INEX)
12634 fputs ("INEX", stdout), first = 0;
12635 if (mask & OEX_FPU_UFLO)
12636 printf ("%sUFLO", first ? "" : "|"), first = 0;
12637 if (mask & OEX_FPU_OFLO)
12638 printf ("%sOFLO", first ? "" : "|"), first = 0;
12639 if (mask & OEX_FPU_DIV0)
12640 printf ("%sDIV0", first ? "" : "|"), first = 0;
12641 if (mask & OEX_FPU_INVAL)
12642 printf ("%sINVAL", first ? "" : "|");
12643 }
5b18a4bc 12644 else
19e6b90e 12645 fputs ("0", stdout);
5b18a4bc 12646}
103f02d3 12647
f6f0e17b
NC		 12648/* Display's the value of TAG at location P. If TAG is
12649 greater than 0 it is assumed to be an unknown tag, and
12650 a message is printed to this effect. Otherwise it is
12651 assumed that a message has already been printed.
12652
12653 If the bottom bit of TAG is set it assumed to have a
12654 string value, otherwise it is assumed to have an integer
12655 value.
12656
12657 Returns an updated P pointing to the first unread byte
12658 beyond the end of TAG's value.
12659
12660 Reads at or beyond END will not be made. */
12661
12662static unsigned char *
12663display_tag_value (int tag,
12664 unsigned char * p,
12665 const unsigned char * const end)
12666{
12667 unsigned long val;
12668
12669 if (tag > 0)
12670 printf (" Tag_unknown_%d: ", tag);
12671
12672 if (p >= end)
12673 {
4082ef84 12674 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12675 }
12676 else if (tag & 1)
12677 {
071436c6
NC		 12678 /* PR 17531 file: 027-19978-0.004. */
12679 size_t maxlen = (end - p) - 1;
12680
12681 putchar ('"');
4082ef84
NC		 12682 if (maxlen > 0)
12683 {
12684 print_symbol ((int) maxlen, (const char *) p);
12685 p += strnlen ((char *) p, maxlen) + 1;
12686 }
12687 else
12688 {
12689 printf (_("<corrupt string tag>"));
12690 p = (unsigned char *) end;
12691 }
071436c6 12692 printf ("\"\n");
f6f0e17b
NC		 12693 }
12694 else
12695 {
12696 unsigned int len;
12697
12698 val = read_uleb128 (p, &len, end);
12699 p += len;
12700 printf ("%ld (0x%lx)\n", val, val);
12701 }
12702
4082ef84 12703 assert (p <= end);
f6f0e17b
NC		 12704 return p;
12705}
12706
11c1ff18
PB		 12707/* ARM EABI attributes section. */
12708typedef struct
12709{
70e99720 12710 unsigned int tag;
2cf0635d 12711 const char * name;
11c1ff18 12712 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12713 unsigned int type;
2cf0635d 12714 const char ** table;
11c1ff18
PB		 12715} arm_attr_public_tag;
12716
2cf0635d 12717static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12718 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12719 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12720static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12721static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12722 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12723static const char * arm_attr_tag_FP_arch[] =
bca38921 12724 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12725 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12726static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12727static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12728 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12729static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12730 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12731 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12732static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12733 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12734static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12735 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12736static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12737 {"Absolute", "PC-relative", "None"};
2cf0635d 12738static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12739 {"None", "direct", "GOT-indirect"};
2cf0635d 12740static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12741 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12742static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12743static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12744 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12745static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12746static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12747static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12748 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12749static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12750 {"Unused", "small", "int", "forced to int"};
2cf0635d 12751static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12752 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12753static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12754 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12755static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12756 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12757static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12758 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12759 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12760static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12761 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12762 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12763static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12764static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12765 {"Not Allowed", "Allowed"};
2cf0635d 12766static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12767 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12768static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12769 {"Not Allowed", "Allowed"};
12770static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12771 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12772 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12773static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12774static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12775 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12776 "TrustZone and Virtualization Extensions"};
dd24e3da 12777static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12778 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12779
12780#define LOOKUP(id, name) \
12781 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12782static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12783{
12784 {4, "CPU_raw_name", 1, NULL},
12785 {5, "CPU_name", 1, NULL},
12786 LOOKUP(6, CPU_arch),
12787 {7, "CPU_arch_profile", 0, NULL},
12788 LOOKUP(8, ARM_ISA_use),
12789 LOOKUP(9, THUMB_ISA_use),
75375b3e 12790 LOOKUP(10, FP_arch),
11c1ff18 12791 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12792 LOOKUP(12, Advanced_SIMD_arch),
12793 LOOKUP(13, PCS_config),
11c1ff18
PB		 12794 LOOKUP(14, ABI_PCS_R9_use),
12795 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12796 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12797 LOOKUP(17, ABI_PCS_GOT_use),
12798 LOOKUP(18, ABI_PCS_wchar_t),
12799 LOOKUP(19, ABI_FP_rounding),
12800 LOOKUP(20, ABI_FP_denormal),
12801 LOOKUP(21, ABI_FP_exceptions),
12802 LOOKUP(22, ABI_FP_user_exceptions),
12803 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12804 {24, "ABI_align_needed", 0, NULL},
12805 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12806 LOOKUP(26, ABI_enum_size),
12807 LOOKUP(27, ABI_HardFP_use),
12808 LOOKUP(28, ABI_VFP_args),
12809 LOOKUP(29, ABI_WMMX_args),
12810 LOOKUP(30, ABI_optimization_goals),
12811 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12812 {32, "compatibility", 0, NULL},
f5f53991 12813 LOOKUP(34, CPU_unaligned_access),
75375b3e 12814 LOOKUP(36, FP_HP_extension),
8e79c3df 12815 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12816 LOOKUP(42, MPextension_use),
12817 LOOKUP(44, DIV_use),
f5f53991
AS		 12818 {64, "nodefaults", 0, NULL},
12819 {65, "also_compatible_with", 0, NULL},
12820 LOOKUP(66, T2EE_use),
12821 {67, "conformance", 1, NULL},
12822 LOOKUP(68, Virtualization_use),
cd21e546 12823 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12824};
12825#undef LOOKUP
12826
11c1ff18 12827static unsigned char *
f6f0e17b
NC		 12828display_arm_attribute (unsigned char * p,
12829 const unsigned char * const end)
11c1ff18 12830{
70e99720 12831 unsigned int tag;
11c1ff18 12832 unsigned int len;
70e99720 12833 unsigned int val;
2cf0635d 12834 arm_attr_public_tag * attr;
11c1ff18 12835 unsigned i;
70e99720 12836 unsigned int type;
11c1ff18 12837
f6f0e17b 12838 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12839 p += len;
12840 attr = NULL;
2cf0635d 12841 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12842 {
12843 if (arm_attr_public_tags[i].tag == tag)
12844 {
12845 attr = &arm_attr_public_tags[i];
12846 break;
12847 }
12848 }
12849
12850 if (attr)
12851 {
12852 printf (" Tag_%s: ", attr->name);
12853 switch (attr->type)
12854 {
12855 case 0:
12856 switch (tag)
12857 {
12858 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12859 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12860 p += len;
12861 switch (val)
12862 {
2b692964
NC		 12863 case 0: printf (_("None\n")); break;
12864 case 'A': printf (_("Application\n")); break;
12865 case 'R': printf (_("Realtime\n")); break;
12866 case 'M': printf (_("Microcontroller\n")); break;
12867 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12868 default: printf ("??? (%d)\n", val); break;
12869 }
12870 break;
12871
75375b3e 12872 case 24: /* Tag_align_needed. */
f6f0e17b 12873 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12874 p += len;
12875 switch (val)
12876 {
2b692964
NC		 12877 case 0: printf (_("None\n")); break;
12878 case 1: printf (_("8-byte\n")); break;
12879 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12880 case 3: printf ("??? 3\n"); break;
12881 default:
12882 if (val <= 12)
dd24e3da 12883 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12884 1 << val);
12885 else
12886 printf ("??? (%d)\n", val);
12887 break;
12888 }
12889 break;
12890
12891 case 25: /* Tag_align_preserved. */
f6f0e17b 12892 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12893 p += len;
12894 switch (val)
12895 {
2b692964
NC		 12896 case 0: printf (_("None\n")); break;
12897 case 1: printf (_("8-byte, except leaf SP\n")); break;
12898 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12899 case 3: printf ("??? 3\n"); break;
12900 default:
12901 if (val <= 12)
dd24e3da 12902 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12903 1 << val);
12904 else
12905 printf ("??? (%d)\n", val);
12906 break;
12907 }
12908 break;
12909
11c1ff18 12910 case 32: /* Tag_compatibility. */
071436c6 12911 {
071436c6
NC		 12912 val = read_uleb128 (p, &len, end);
12913 p += len;
071436c6 12914 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12915 if (p < end - 1)
12916 {
12917 size_t maxlen = (end - p) - 1;
12918
12919 print_symbol ((int) maxlen, (const char *) p);
12920 p += strnlen ((char *) p, maxlen) + 1;
12921 }
12922 else
12923 {
12924 printf (_("<corrupt>"));
12925 p = (unsigned char *) end;
12926 }
071436c6 12927 putchar ('\n');
071436c6 12928 }
11c1ff18
PB		 12929 break;
12930
f5f53991 12931 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12932 /* PR 17531: file: 001-505008-0.01. */
12933 if (p < end)
12934 p++;
2b692964 12935 printf (_("True\n"));
f5f53991
AS		 12936 break;
12937
12938 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12939 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12940 p += len;
12941 if (val == 6 /* Tag_CPU_arch. */)
12942 {
f6f0e17b 12943 val = read_uleb128 (p, &len, end);
f5f53991 12944 p += len;
071436c6 12945 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12946 printf ("??? (%d)\n", val);
12947 else
12948 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12949 }
12950 else
12951 printf ("???\n");
071436c6
NC		 12952 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12953 ;
f5f53991
AS		 12954 break;
12955
11c1ff18 12956 default:
bee0ee85
NC		 12957 printf (_("<unknown: %d>\n"), tag);
12958 break;
11c1ff18
PB		 12959 }
12960 return p;
12961
12962 case 1:
f6f0e17b 12963 return display_tag_value (-1, p, end);
11c1ff18 12964 case 2:
f6f0e17b 12965 return display_tag_value (0, p, end);
11c1ff18
PB		 12966
12967 default:
12968 assert (attr->type & 0x80);
f6f0e17b 12969 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12970 p += len;
12971 type = attr->type & 0x7f;
12972 if (val >= type)
12973 printf ("??? (%d)\n", val);
12974 else
12975 printf ("%s\n", attr->table[val]);
12976 return p;
12977 }
12978 }
11c1ff18 12979
f6f0e17b 12980 return display_tag_value (tag, p, end);
11c1ff18
PB		 12981}
12982
104d59d1 12983static unsigned char *
60bca95a 12984display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 12985 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12986 const unsigned char * const end)
104d59d1
JM		 12987{
12988 int tag;
12989 unsigned int len;
12990 int val;
104d59d1 12991
f6f0e17b 12992 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 12993 p += len;
12994
12995 /* Tag_compatibility is the only generic GNU attribute defined at
12996 present. */
12997 if (tag == 32)
12998 {
f6f0e17b 12999 val = read_uleb128 (p, &len, end);
104d59d1 13000 p += len;
071436c6
NC		 13001
13002 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13003 if (p == end)
13004 {
071436c6 13005 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13006 warn (_("corrupt vendor attribute\n"));
13007 }
13008 else
13009 {
4082ef84
NC		 13010 if (p < end - 1)
13011 {
13012 size_t maxlen = (end - p) - 1;
071436c6 13013
4082ef84
NC		 13014 print_symbol ((int) maxlen, (const char *) p);
13015 p += strnlen ((char *) p, maxlen) + 1;
13016 }
13017 else
13018 {
13019 printf (_("<corrupt>"));
13020 p = (unsigned char *) end;
13021 }
071436c6 13022 putchar ('\n');
f6f0e17b 13023 }
104d59d1
JM		 13024 return p;
13025 }
13026
13027 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13028 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13029
f6f0e17b 13030 return display_tag_value (tag, p, end);
104d59d1
JM		 13031}
13032
34c8bcba 13033static unsigned char *
f6f0e17b
NC		 13034display_power_gnu_attribute (unsigned char * p,
13035 int tag,
13036 const unsigned char * const end)
34c8bcba 13037{
34c8bcba
JM		 13038 unsigned int len;
13039 int val;
13040
13041 if (tag == Tag_GNU_Power_ABI_FP)
13042 {
f6f0e17b 13043 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13044 p += len;
13045 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13046
34c8bcba
JM		 13047 switch (val)
13048 {
13049 case 0:
2b692964 13050 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13051 break;
13052 case 1:
2b692964 13053 printf (_("Hard float\n"));
34c8bcba
JM		 13054 break;
13055 case 2:
2b692964 13056 printf (_("Soft float\n"));
34c8bcba 13057 break;
3c7b9897 13058 case 3:
2b692964 13059 printf (_("Single-precision hard float\n"));
3c7b9897 13060 break;
34c8bcba
JM		 13061 default:
13062 printf ("??? (%d)\n", val);
13063 break;
13064 }
13065 return p;
13066 }
13067
c6e65352
DJ		 13068 if (tag == Tag_GNU_Power_ABI_Vector)
13069 {
f6f0e17b 13070 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13071 p += len;
13072 printf (" Tag_GNU_Power_ABI_Vector: ");
13073 switch (val)
13074 {
13075 case 0:
2b692964 13076 printf (_("Any\n"));
c6e65352
DJ		 13077 break;
13078 case 1:
2b692964 13079 printf (_("Generic\n"));
c6e65352
DJ		 13080 break;
13081 case 2:
13082 printf ("AltiVec\n");
13083 break;
13084 case 3:
13085 printf ("SPE\n");
13086 break;
13087 default:
13088 printf ("??? (%d)\n", val);
13089 break;
13090 }
13091 return p;
13092 }
13093
f82e0623
NF		 13094 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13095 {
f6f0e17b
NC		 13096 if (p == end)
13097 {
071436c6 13098 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13099 return p;
13100 }
0b4362b0 13101
f6f0e17b 13102 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13103 p += len;
13104 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13105 switch (val)
13106 {
13107 case 0:
2b692964 13108 printf (_("Any\n"));
f82e0623
NF		 13109 break;
13110 case 1:
13111 printf ("r3/r4\n");
13112 break;
13113 case 2:
2b692964 13114 printf (_("Memory\n"));
f82e0623
NF		 13115 break;
13116 default:
13117 printf ("??? (%d)\n", val);
13118 break;
13119 }
13120 return p;
13121 }
13122
f6f0e17b 13123 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13124}
13125
643f7afb
AK		 13126static unsigned char *
13127display_s390_gnu_attribute (unsigned char * p,
13128 int tag,
13129 const unsigned char * const end)
13130{
13131 unsigned int len;
13132 int val;
13133
13134 if (tag == Tag_GNU_S390_ABI_Vector)
13135 {
13136 val = read_uleb128 (p, &len, end);
13137 p += len;
13138 printf (" Tag_GNU_S390_ABI_Vector: ");
13139
13140 switch (val)
13141 {
13142 case 0:
13143 printf (_("any\n"));
13144 break;
13145 case 1:
13146 printf (_("software\n"));
13147 break;
13148 case 2:
13149 printf (_("hardware\n"));
13150 break;
13151 default:
13152 printf ("??? (%d)\n", val);
13153 break;
13154 }
13155 return p;
13156 }
13157
13158 return display_tag_value (tag & 1, p, end);
13159}
13160
9e8c70f9
DM		 13161static void
13162display_sparc_hwcaps (int mask)
13163{
13164 if (mask)
13165 {
13166 int first = 1;
071436c6 13167
9e8c70f9
DM		 13168 if (mask & ELF_SPARC_HWCAP_MUL32)
13169 fputs ("mul32", stdout), first = 0;
13170 if (mask & ELF_SPARC_HWCAP_DIV32)
13171 printf ("%sdiv32", first ? "" : "|"), first = 0;
13172 if (mask & ELF_SPARC_HWCAP_FSMULD)
13173 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13174 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13175 printf ("%sv8plus", first ? "" : "|"), first = 0;
13176 if (mask & ELF_SPARC_HWCAP_POPC)
13177 printf ("%spopc", first ? "" : "|"), first = 0;
13178 if (mask & ELF_SPARC_HWCAP_VIS)
13179 printf ("%svis", first ? "" : "|"), first = 0;
13180 if (mask & ELF_SPARC_HWCAP_VIS2)
13181 printf ("%svis2", first ? "" : "|"), first = 0;
13182 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13183 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13184 if (mask & ELF_SPARC_HWCAP_FMAF)
13185 printf ("%sfmaf", first ? "" : "|"), first = 0;
13186 if (mask & ELF_SPARC_HWCAP_VIS3)
13187 printf ("%svis3", first ? "" : "|"), first = 0;
13188 if (mask & ELF_SPARC_HWCAP_HPC)
13189 printf ("%shpc", first ? "" : "|"), first = 0;
13190 if (mask & ELF_SPARC_HWCAP_RANDOM)
13191 printf ("%srandom", first ? "" : "|"), first = 0;
13192 if (mask & ELF_SPARC_HWCAP_TRANS)
13193 printf ("%strans", first ? "" : "|"), first = 0;
13194 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13195 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13196 if (mask & ELF_SPARC_HWCAP_IMA)
13197 printf ("%sima", first ? "" : "|"), first = 0;
13198 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13199 printf ("%scspare", first ? "" : "|"), first = 0;
13200 }
13201 else
071436c6
NC		 13202 fputc ('0', stdout);
13203 fputc ('\n', stdout);
9e8c70f9
DM		 13204}
13205
3d68f91c
JM		 13206static void
13207display_sparc_hwcaps2 (int mask)
13208{
13209 if (mask)
13210 {
13211 int first = 1;
071436c6 13212
3d68f91c
JM		 13213 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13214 fputs ("fjathplus", stdout), first = 0;
13215 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13216 printf ("%svis3b", first ? "" : "|"), first = 0;
13217 if (mask & ELF_SPARC_HWCAP2_ADP)
13218 printf ("%sadp", first ? "" : "|"), first = 0;
13219 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13220 printf ("%ssparc5", first ? "" : "|"), first = 0;
13221 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13222 printf ("%smwait", first ? "" : "|"), first = 0;
13223 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13224 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13225 if (mask & ELF_SPARC_HWCAP2_XMONT)
13226 printf ("%sxmont2", first ? "" : "|"), first = 0;
13227 if (mask & ELF_SPARC_HWCAP2_NSEC)
13228 printf ("%snsec", first ? "" : "|"), first = 0;
13229 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13230 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13231 if (mask & ELF_SPARC_HWCAP2_FJDES)
13232 printf ("%sfjdes", first ? "" : "|"), first = 0;
13233 if (mask & ELF_SPARC_HWCAP2_FJAES)
13234 printf ("%sfjaes", first ? "" : "|"), first = 0;
13235 }
13236 else
071436c6
NC		 13237 fputc ('0', stdout);
13238 fputc ('\n', stdout);
3d68f91c
JM		 13239}
13240
9e8c70f9 13241static unsigned char *
f6f0e17b
NC		 13242display_sparc_gnu_attribute (unsigned char * p,
13243 int tag,
13244 const unsigned char * const end)
9e8c70f9 13245{
3d68f91c
JM		 13246 unsigned int len;
13247 int val;
13248
9e8c70f9
DM		 13249 if (tag == Tag_GNU_Sparc_HWCAPS)
13250 {
f6f0e17b 13251 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13252 p += len;
13253 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13254 display_sparc_hwcaps (val);
13255 return p;
3d68f91c
JM		 13256 }
13257 if (tag == Tag_GNU_Sparc_HWCAPS2)
13258 {
13259 val = read_uleb128 (p, &len, end);
13260 p += len;
13261 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13262 display_sparc_hwcaps2 (val);
13263 return p;
13264 }
9e8c70f9 13265
f6f0e17b 13266 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13267}
13268
351cdf24
MF		 13269static void
13270print_mips_fp_abi_value (int val)
13271{
13272 switch (val)
13273 {
13274 case Val_GNU_MIPS_ABI_FP_ANY:
13275 printf (_("Hard or soft float\n"));
13276 break;
13277 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13278 printf (_("Hard float (double precision)\n"));
13279 break;
13280 case Val_GNU_MIPS_ABI_FP_SINGLE:
13281 printf (_("Hard float (single precision)\n"));
13282 break;
13283 case Val_GNU_MIPS_ABI_FP_SOFT:
13284 printf (_("Soft float\n"));
13285 break;
13286 case Val_GNU_MIPS_ABI_FP_OLD_64:
13287 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13288 break;
13289 case Val_GNU_MIPS_ABI_FP_XX:
13290 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13291 break;
13292 case Val_GNU_MIPS_ABI_FP_64:
13293 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13294 break;
13295 case Val_GNU_MIPS_ABI_FP_64A:
13296 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13297 break;
3350cc01
CM		 13298 case Val_GNU_MIPS_ABI_FP_NAN2008:
13299 printf (_("NaN 2008 compatibility\n"));
13300 break;
351cdf24
MF		 13301 default:
13302 printf ("??? (%d)\n", val);
13303 break;
13304 }
13305}
13306
2cf19d5c 13307static unsigned char *
f6f0e17b
NC		 13308display_mips_gnu_attribute (unsigned char * p,
13309 int tag,
13310 const unsigned char * const end)
2cf19d5c 13311{
2cf19d5c
JM		 13312 if (tag == Tag_GNU_MIPS_ABI_FP)
13313 {
f6f0e17b
NC		 13314 unsigned int len;
13315 int val;
13316
13317 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13318 p += len;
13319 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13320
351cdf24
MF		 13321 print_mips_fp_abi_value (val);
13322
2cf19d5c
JM		 13323 return p;
13324 }
13325
a9f58168
CF		 13326 if (tag == Tag_GNU_MIPS_ABI_MSA)
13327 {
13328 unsigned int len;
13329 int val;
13330
13331 val = read_uleb128 (p, &len, end);
13332 p += len;
13333 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13334
13335 switch (val)
13336 {
13337 case Val_GNU_MIPS_ABI_MSA_ANY:
13338 printf (_("Any MSA or not\n"));
13339 break;
13340 case Val_GNU_MIPS_ABI_MSA_128:
13341 printf (_("128-bit MSA\n"));
13342 break;
13343 default:
13344 printf ("??? (%d)\n", val);
13345 break;
13346 }
13347 return p;
13348 }
13349
f6f0e17b 13350 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13351}
13352
59e6276b 13353static unsigned char *
f6f0e17b
NC		 13354display_tic6x_attribute (unsigned char * p,
13355 const unsigned char * const end)
59e6276b
JM		 13356{
13357 int tag;
13358 unsigned int len;
13359 int val;
13360
f6f0e17b 13361 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13362 p += len;
13363
13364 switch (tag)
13365 {
75fa6dc1 13366 case Tag_ISA:
f6f0e17b 13367 val = read_uleb128 (p, &len, end);
59e6276b 13368 p += len;
75fa6dc1 13369 printf (" Tag_ISA: ");
59e6276b
JM		 13370
13371 switch (val)
13372 {
75fa6dc1 13373 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13374 printf (_("None\n"));
13375 break;
75fa6dc1 13376 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13377 printf ("C62x\n");
13378 break;
75fa6dc1 13379 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13380 printf ("C67x\n");
13381 break;
75fa6dc1 13382 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13383 printf ("C67x+\n");
13384 break;
75fa6dc1 13385 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13386 printf ("C64x\n");
13387 break;
75fa6dc1 13388 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13389 printf ("C64x+\n");
13390 break;
75fa6dc1 13391 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13392 printf ("C674x\n");
13393 break;
13394 default:
13395 printf ("??? (%d)\n", val);
13396 break;
13397 }
13398 return p;
13399
87779176 13400 case Tag_ABI_wchar_t:
f6f0e17b 13401 val = read_uleb128 (p, &len, end);
87779176
JM		 13402 p += len;
13403 printf (" Tag_ABI_wchar_t: ");
13404 switch (val)
13405 {
13406 case 0:
13407 printf (_("Not used\n"));
13408 break;
13409 case 1:
13410 printf (_("2 bytes\n"));
13411 break;
13412 case 2:
13413 printf (_("4 bytes\n"));
13414 break;
13415 default:
13416 printf ("??? (%d)\n", val);
13417 break;
13418 }
13419 return p;
13420
13421 case Tag_ABI_stack_align_needed:
f6f0e17b 13422 val = read_uleb128 (p, &len, end);
87779176
JM		 13423 p += len;
13424 printf (" Tag_ABI_stack_align_needed: ");
13425 switch (val)
13426 {
13427 case 0:
13428 printf (_("8-byte\n"));
13429 break;
13430 case 1:
13431 printf (_("16-byte\n"));
13432 break;
13433 default:
13434 printf ("??? (%d)\n", val);
13435 break;
13436 }
13437 return p;
13438
13439 case Tag_ABI_stack_align_preserved:
f6f0e17b 13440 val = read_uleb128 (p, &len, end);
87779176
JM		 13441 p += len;
13442 printf (" Tag_ABI_stack_align_preserved: ");
13443 switch (val)
13444 {
13445 case 0:
13446 printf (_("8-byte\n"));
13447 break;
13448 case 1:
13449 printf (_("16-byte\n"));
13450 break;
13451 default:
13452 printf ("??? (%d)\n", val);
13453 break;
13454 }
13455 return p;
13456
b5593623 13457 case Tag_ABI_DSBT:
f6f0e17b 13458 val = read_uleb128 (p, &len, end);
b5593623
JM		 13459 p += len;
13460 printf (" Tag_ABI_DSBT: ");
13461 switch (val)
13462 {
13463 case 0:
13464 printf (_("DSBT addressing not used\n"));
13465 break;
13466 case 1:
13467 printf (_("DSBT addressing used\n"));
13468 break;
13469 default:
13470 printf ("??? (%d)\n", val);
13471 break;
13472 }
13473 return p;
13474
87779176 13475 case Tag_ABI_PID:
f6f0e17b 13476 val = read_uleb128 (p, &len, end);
87779176
JM		 13477 p += len;
13478 printf (" Tag_ABI_PID: ");
13479 switch (val)
13480 {
13481 case 0:
13482 printf (_("Data addressing position-dependent\n"));
13483 break;
13484 case 1:
13485 printf (_("Data addressing position-independent, GOT near DP\n"));
13486 break;
13487 case 2:
13488 printf (_("Data addressing position-independent, GOT far from DP\n"));
13489 break;
13490 default:
13491 printf ("??? (%d)\n", val);
13492 break;
13493 }
13494 return p;
13495
13496 case Tag_ABI_PIC:
f6f0e17b 13497 val = read_uleb128 (p, &len, end);
87779176
JM		 13498 p += len;
13499 printf (" Tag_ABI_PIC: ");
13500 switch (val)
13501 {
13502 case 0:
13503 printf (_("Code addressing position-dependent\n"));
13504 break;
13505 case 1:
13506 printf (_("Code addressing position-independent\n"));
13507 break;
13508 default:
13509 printf ("??? (%d)\n", val);
13510 break;
13511 }
13512 return p;
13513
13514 case Tag_ABI_array_object_alignment:
f6f0e17b 13515 val = read_uleb128 (p, &len, end);
87779176
JM		 13516 p += len;
13517 printf (" Tag_ABI_array_object_alignment: ");
13518 switch (val)
13519 {
13520 case 0:
13521 printf (_("8-byte\n"));
13522 break;
13523 case 1:
13524 printf (_("4-byte\n"));
13525 break;
13526 case 2:
13527 printf (_("16-byte\n"));
13528 break;
13529 default:
13530 printf ("??? (%d)\n", val);
13531 break;
13532 }
13533 return p;
13534
13535 case Tag_ABI_array_object_align_expected:
f6f0e17b 13536 val = read_uleb128 (p, &len, end);
87779176
JM		 13537 p += len;
13538 printf (" Tag_ABI_array_object_align_expected: ");
13539 switch (val)
13540 {
13541 case 0:
13542 printf (_("8-byte\n"));
13543 break;
13544 case 1:
13545 printf (_("4-byte\n"));
13546 break;
13547 case 2:
13548 printf (_("16-byte\n"));
13549 break;
13550 default:
13551 printf ("??? (%d)\n", val);
13552 break;
13553 }
13554 return p;
13555
3cbd1c06 13556 case Tag_ABI_compatibility:
071436c6 13557 {
071436c6
NC		 13558 val = read_uleb128 (p, &len, end);
13559 p += len;
13560 printf (" Tag_ABI_compatibility: ");
071436c6 13561 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13562 if (p < end - 1)
13563 {
13564 size_t maxlen = (end - p) - 1;
13565
13566 print_symbol ((int) maxlen, (const char *) p);
13567 p += strnlen ((char *) p, maxlen) + 1;
13568 }
13569 else
13570 {
13571 printf (_("<corrupt>"));
13572 p = (unsigned char *) end;
13573 }
071436c6 13574 putchar ('\n');
071436c6
NC		 13575 return p;
13576 }
87779176
JM		 13577
13578 case Tag_ABI_conformance:
071436c6 13579 {
4082ef84
NC		 13580 printf (" Tag_ABI_conformance: \"");
13581 if (p < end - 1)
13582 {
13583 size_t maxlen = (end - p) - 1;
071436c6 13584
4082ef84
NC		 13585 print_symbol ((int) maxlen, (const char *) p);
13586 p += strnlen ((char *) p, maxlen) + 1;
13587 }
13588 else
13589 {
13590 printf (_("<corrupt>"));
13591 p = (unsigned char *) end;
13592 }
071436c6 13593 printf ("\"\n");
071436c6
NC		 13594 return p;
13595 }
59e6276b
JM		 13596 }
13597
f6f0e17b
NC		 13598 return display_tag_value (tag, p, end);
13599}
59e6276b 13600
f6f0e17b
NC		 13601static void
13602display_raw_attribute (unsigned char * p, unsigned char * end)
13603{
13604 unsigned long addr = 0;
13605 size_t bytes = end - p;
13606
e0a31db1 13607 assert (end > p);
f6f0e17b 13608 while (bytes)
87779176 13609 {
f6f0e17b
NC		 13610 int j;
13611 int k;
13612 int lbytes = (bytes > 16 ? 16 : bytes);
13613
13614 printf (" 0x%8.8lx ", addr);
13615
13616 for (j = 0; j < 16; j++)
13617 {
13618 if (j < lbytes)
13619 printf ("%2.2x", p[j]);
13620 else
13621 printf (" ");
13622
13623 if ((j & 3) == 3)
13624 printf (" ");
13625 }
13626
13627 for (j = 0; j < lbytes; j++)
13628 {
13629 k = p[j];
13630 if (k >= ' ' && k < 0x7f)
13631 printf ("%c", k);
13632 else
13633 printf (".");
13634 }
13635
13636 putchar ('\n');
13637
13638 p += lbytes;
13639 bytes -= lbytes;
13640 addr += lbytes;
87779176 13641 }
59e6276b 13642
f6f0e17b 13643 putchar ('\n');
59e6276b
JM		 13644}
13645
13761a11
NC		 13646static unsigned char *
13647display_msp430x_attribute (unsigned char * p,
13648 const unsigned char * const end)
13649{
13650 unsigned int len;
13651 int val;
13652 int tag;
13653
13654 tag = read_uleb128 (p, & len, end);
13655 p += len;
0b4362b0 13656
13761a11
NC		 13657 switch (tag)
13658 {
13659 case OFBA_MSPABI_Tag_ISA:
13660 val = read_uleb128 (p, &len, end);
13661 p += len;
13662 printf (" Tag_ISA: ");
13663 switch (val)
13664 {
13665 case 0: printf (_("None\n")); break;
13666 case 1: printf (_("MSP430\n")); break;
13667 case 2: printf (_("MSP430X\n")); break;
13668 default: printf ("??? (%d)\n", val); break;
13669 }
13670 break;
13671
13672 case OFBA_MSPABI_Tag_Code_Model:
13673 val = read_uleb128 (p, &len, end);
13674 p += len;
13675 printf (" Tag_Code_Model: ");
13676 switch (val)
13677 {
13678 case 0: printf (_("None\n")); break;
13679 case 1: printf (_("Small\n")); break;
13680 case 2: printf (_("Large\n")); break;
13681 default: printf ("??? (%d)\n", val); break;
13682 }
13683 break;
13684
13685 case OFBA_MSPABI_Tag_Data_Model:
13686 val = read_uleb128 (p, &len, end);
13687 p += len;
13688 printf (" Tag_Data_Model: ");
13689 switch (val)
13690 {
13691 case 0: printf (_("None\n")); break;
13692 case 1: printf (_("Small\n")); break;
13693 case 2: printf (_("Large\n")); break;
13694 case 3: printf (_("Restricted Large\n")); break;
13695 default: printf ("??? (%d)\n", val); break;
13696 }
13697 break;
13698
13699 default:
13700 printf (_(" <unknown tag %d>: "), tag);
13701
13702 if (tag & 1)
13703 {
071436c6 13704 putchar ('"');
4082ef84
NC		 13705 if (p < end - 1)
13706 {
13707 size_t maxlen = (end - p) - 1;
13708
13709 print_symbol ((int) maxlen, (const char *) p);
13710 p += strnlen ((char *) p, maxlen) + 1;
13711 }
13712 else
13713 {
13714 printf (_("<corrupt>"));
13715 p = (unsigned char *) end;
13716 }
071436c6 13717 printf ("\"\n");
13761a11
NC		 13718 }
13719 else
13720 {
13721 val = read_uleb128 (p, &len, end);
13722 p += len;
13723 printf ("%d (0x%x)\n", val, val);
13724 }
13725 break;
13726 }
13727
4082ef84 13728 assert (p <= end);
13761a11
NC		 13729 return p;
13730}
13731
11c1ff18 13732static int
60bca95a
NC		 13733process_attributes (FILE * file,
13734 const char * public_name,
104d59d1 13735 unsigned int proc_type,
f6f0e17b
NC		 13736 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13737 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13738{
2cf0635d 13739 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13740 unsigned i;
13741
13742 /* Find the section header so that we get the size. */
13743 for (i = 0, sect = section_headers;
13744 i < elf_header.e_shnum;
13745 i++, sect++)
13746 {
071436c6
NC		 13747 unsigned char * contents;
13748 unsigned char * p;
13749
104d59d1 13750 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13751 continue;
13752
3f5e193b
NC		 13753 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13754 sect->sh_size, _("attributes"));
60bca95a 13755 if (contents == NULL)
11c1ff18 13756 continue;
60bca95a 13757
11c1ff18
PB		 13758 p = contents;
13759 if (*p == 'A')
13760 {
071436c6
NC		 13761 bfd_vma section_len;
13762
13763 section_len = sect->sh_size - 1;
11c1ff18 13764 p++;
60bca95a 13765
071436c6 13766 while (section_len > 0)
11c1ff18 13767 {
071436c6 13768 bfd_vma attr_len;
e9847026 13769 unsigned int namelen;
11c1ff18 13770 bfd_boolean public_section;
104d59d1 13771 bfd_boolean gnu_section;
11c1ff18 13772
071436c6 13773 if (section_len <= 4)
e0a31db1
NC		 13774 {
13775 error (_("Tag section ends prematurely\n"));
13776 break;
13777 }
071436c6 13778 attr_len = byte_get (p, 4);
11c1ff18 13779 p += 4;
60bca95a 13780
071436c6 13781 if (attr_len > section_len)
11c1ff18 13782 {
071436c6
NC		 13783 error (_("Bad attribute length (%u > %u)\n"),
13784 (unsigned) attr_len, (unsigned) section_len);
13785 attr_len = section_len;
11c1ff18 13786 }
74e1a04b 13787 /* PR 17531: file: 001-101425-0.004 */
071436c6 13788 else if (attr_len < 5)
74e1a04b 13789 {
071436c6 13790 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13791 break;
13792 }
e9847026 13793
071436c6
NC		 13794 section_len -= attr_len;
13795 attr_len -= 4;
13796
13797 namelen = strnlen ((char *) p, attr_len) + 1;
13798 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13799 {
13800 error (_("Corrupt attribute section name\n"));
13801 break;
13802 }
13803
071436c6
NC		 13804 printf (_("Attribute Section: "));
13805 print_symbol (INT_MAX, (const char *) p);
13806 putchar ('\n');
60bca95a
NC		 13807
13808 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13809 public_section = TRUE;
13810 else
13811 public_section = FALSE;
60bca95a
NC		 13812
13813 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13814 gnu_section = TRUE;
13815 else
13816 gnu_section = FALSE;
60bca95a 13817
11c1ff18 13818 p += namelen;
071436c6 13819 attr_len -= namelen;
e0a31db1 13820
071436c6 13821 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13822 {
e0a31db1 13823 int tag;
11c1ff18
PB		 13824 int val;
13825 bfd_vma size;
071436c6 13826 unsigned char * end;
60bca95a 13827
e0a31db1 13828 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13829 if (attr_len < 6)
e0a31db1
NC		 13830 {
13831 error (_("Unused bytes at end of section\n"));
13832 section_len = 0;
13833 break;
13834 }
13835
13836 tag = *(p++);
11c1ff18 13837 size = byte_get (p, 4);
071436c6 13838 if (size > attr_len)
11c1ff18 13839 {
e9847026 13840 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13841 (unsigned) size, (unsigned) attr_len);
13842 size = attr_len;
11c1ff18 13843 }
e0a31db1
NC		 13844 /* PR binutils/17531: Safe handling of corrupt files. */
13845 if (size < 6)
13846 {
13847 error (_("Bad subsection length (%u < 6)\n"),
13848 (unsigned) size);
13849 section_len = 0;
13850 break;
13851 }
60bca95a 13852
071436c6 13853 attr_len -= size;
11c1ff18 13854 end = p + size - 1;
071436c6 13855 assert (end <= contents + sect->sh_size);
11c1ff18 13856 p += 4;
60bca95a 13857
11c1ff18
PB		 13858 switch (tag)
13859 {
13860 case 1:
2b692964 13861 printf (_("File Attributes\n"));
11c1ff18
PB		 13862 break;
13863 case 2:
2b692964 13864 printf (_("Section Attributes:"));
11c1ff18
PB		 13865 goto do_numlist;
13866 case 3:
2b692964 13867 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13868 do_numlist:
13869 for (;;)
13870 {
91d6fa6a 13871 unsigned int j;
60bca95a 13872
f6f0e17b 13873 val = read_uleb128 (p, &j, end);
91d6fa6a 13874 p += j;
11c1ff18
PB		 13875 if (val == 0)
13876 break;
13877 printf (" %d", val);
13878 }
13879 printf ("\n");
13880 break;
13881 default:
2b692964 13882 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13883 public_section = FALSE;
13884 break;
13885 }
60bca95a 13886
071436c6 13887 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13888 {
13889 while (p < end)
f6f0e17b 13890 p = display_pub_attribute (p, end);
071436c6 13891 assert (p <= end);
104d59d1 13892 }
071436c6 13893 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13894 {
13895 while (p < end)
13896 p = display_gnu_attribute (p,
f6f0e17b
NC		 13897 display_proc_gnu_attribute,
13898 end);
071436c6 13899 assert (p <= end);
11c1ff18 13900 }
071436c6 13901 else if (p < end)
11c1ff18 13902 {
071436c6 13903 printf (_(" Unknown attribute:\n"));
f6f0e17b 13904 display_raw_attribute (p, end);
11c1ff18
PB		 13905 p = end;
13906 }
071436c6
NC		 13907 else
13908 attr_len = 0;
11c1ff18
PB		 13909 }
13910 }
13911 }
13912 else
e9847026 13913 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13914
60bca95a 13915 free (contents);
11c1ff18
PB		 13916 }
13917 return 1;
13918}
13919
104d59d1 13920static int
2cf0635d 13921process_arm_specific (FILE * file)
104d59d1
JM		 13922{
13923 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13924 display_arm_attribute, NULL);
13925}
13926
34c8bcba 13927static int
2cf0635d 13928process_power_specific (FILE * file)
34c8bcba
JM		 13929{
13930 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13931 display_power_gnu_attribute);
13932}
13933
643f7afb
AK		 13934static int
13935process_s390_specific (FILE * file)
13936{
13937 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13938 display_s390_gnu_attribute);
13939}
13940
9e8c70f9
DM		 13941static int
13942process_sparc_specific (FILE * file)
13943{
13944 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13945 display_sparc_gnu_attribute);
13946}
13947
59e6276b
JM		 13948static int
13949process_tic6x_specific (FILE * file)
13950{
13951 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13952 display_tic6x_attribute, NULL);
13953}
13954
13761a11
NC		 13955static int
13956process_msp430x_specific (FILE * file)
13957{
13958 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13959 display_msp430x_attribute, NULL);
13960}
13961
ccb4c951
RS		 13962/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13963 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13964 and return the VMA of the next entry, or -1 if there was a problem.
13965 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13966
13967static bfd_vma
82b1b41b
NC		 13968print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13969 unsigned char * data_end)
ccb4c951
RS		 13970{
13971 printf (" ");
13972 print_vma (addr, LONG_HEX);
13973 printf (" ");
13974 if (addr < pltgot + 0xfff0)
13975 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13976 else
13977 printf ("%10s", "");
13978 printf (" ");
13979 if (data == NULL)
2b692964 13980 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 13981 else
13982 {
13983 bfd_vma entry;
82b1b41b 13984 unsigned char * from = data + addr - pltgot;
ccb4c951 13985
82b1b41b
NC		 13986 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13987 {
13988 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13989 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13990 return (bfd_vma) -1;
13991 }
13992 else
13993 {
13994 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13995 print_vma (entry, LONG_HEX);
13996 }
ccb4c951
RS		 13997 }
13998 return addr + (is_32bit_elf ? 4 : 8);
13999}
14000
861fb55a
DJ		 14001/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14002 PLTGOT. Print the Address and Initial fields of an entry at VMA
14003 ADDR and return the VMA of the next entry. */
14004
14005static bfd_vma
2cf0635d 14006print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14007{
14008 printf (" ");
14009 print_vma (addr, LONG_HEX);
14010 printf (" ");
14011 if (data == NULL)
2b692964 14012 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14013 else
14014 {
14015 bfd_vma entry;
14016
14017 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14018 print_vma (entry, LONG_HEX);
14019 }
14020 return addr + (is_32bit_elf ? 4 : 8);
14021}
14022
351cdf24
MF		 14023static void
14024print_mips_ases (unsigned int mask)
14025{
14026 if (mask & AFL_ASE_DSP)
14027 fputs ("\n\tDSP ASE", stdout);
14028 if (mask & AFL_ASE_DSPR2)
14029 fputs ("\n\tDSP R2 ASE", stdout);
14030 if (mask & AFL_ASE_EVA)
14031 fputs ("\n\tEnhanced VA Scheme", stdout);
14032 if (mask & AFL_ASE_MCU)
14033 fputs ("\n\tMCU (MicroController) ASE", stdout);
14034 if (mask & AFL_ASE_MDMX)
14035 fputs ("\n\tMDMX ASE", stdout);
14036 if (mask & AFL_ASE_MIPS3D)
14037 fputs ("\n\tMIPS-3D ASE", stdout);
14038 if (mask & AFL_ASE_MT)
14039 fputs ("\n\tMT ASE", stdout);
14040 if (mask & AFL_ASE_SMARTMIPS)
14041 fputs ("\n\tSmartMIPS ASE", stdout);
14042 if (mask & AFL_ASE_VIRT)
14043 fputs ("\n\tVZ ASE", stdout);
14044 if (mask & AFL_ASE_MSA)
14045 fputs ("\n\tMSA ASE", stdout);
14046 if (mask & AFL_ASE_MIPS16)
14047 fputs ("\n\tMIPS16 ASE", stdout);
14048 if (mask & AFL_ASE_MICROMIPS)
14049 fputs ("\n\tMICROMIPS ASE", stdout);
14050 if (mask & AFL_ASE_XPA)
14051 fputs ("\n\tXPA ASE", stdout);
14052 if (mask == 0)
14053 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14054 else if ((mask & ~AFL_ASE_MASK) != 0)
14055 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14056}
14057
14058static void
14059print_mips_isa_ext (unsigned int isa_ext)
14060{
14061 switch (isa_ext)
14062 {
14063 case 0:
14064 fputs (_("None"), stdout);
14065 break;
14066 case AFL_EXT_XLR:
14067 fputs ("RMI XLR", stdout);
14068 break;
2c629856
N		 14069 case AFL_EXT_OCTEON3:
14070 fputs ("Cavium Networks Octeon3", stdout);
14071 break;
351cdf24
MF		 14072 case AFL_EXT_OCTEON2:
14073 fputs ("Cavium Networks Octeon2", stdout);
14074 break;
14075 case AFL_EXT_OCTEONP:
14076 fputs ("Cavium Networks OcteonP", stdout);
14077 break;
14078 case AFL_EXT_LOONGSON_3A:
14079 fputs ("Loongson 3A", stdout);
14080 break;
14081 case AFL_EXT_OCTEON:
14082 fputs ("Cavium Networks Octeon", stdout);
14083 break;
14084 case AFL_EXT_5900:
14085 fputs ("Toshiba R5900", stdout);
14086 break;
14087 case AFL_EXT_4650:
14088 fputs ("MIPS R4650", stdout);
14089 break;
14090 case AFL_EXT_4010:
14091 fputs ("LSI R4010", stdout);
14092 break;
14093 case AFL_EXT_4100:
14094 fputs ("NEC VR4100", stdout);
14095 break;
14096 case AFL_EXT_3900:
14097 fputs ("Toshiba R3900", stdout);
14098 break;
14099 case AFL_EXT_10000:
14100 fputs ("MIPS R10000", stdout);
14101 break;
14102 case AFL_EXT_SB1:
14103 fputs ("Broadcom SB-1", stdout);
14104 break;
14105 case AFL_EXT_4111:
14106 fputs ("NEC VR4111/VR4181", stdout);
14107 break;
14108 case AFL_EXT_4120:
14109 fputs ("NEC VR4120", stdout);
14110 break;
14111 case AFL_EXT_5400:
14112 fputs ("NEC VR5400", stdout);
14113 break;
14114 case AFL_EXT_5500:
14115 fputs ("NEC VR5500", stdout);
14116 break;
14117 case AFL_EXT_LOONGSON_2E:
14118 fputs ("ST Microelectronics Loongson 2E", stdout);
14119 break;
14120 case AFL_EXT_LOONGSON_2F:
14121 fputs ("ST Microelectronics Loongson 2F", stdout);
14122 break;
14123 default:
00ac7aa0 14124 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14125 }
14126}
14127
14128static int
14129get_mips_reg_size (int reg_size)
14130{
14131 return (reg_size == AFL_REG_NONE) ? 0
14132 : (reg_size == AFL_REG_32) ? 32
14133 : (reg_size == AFL_REG_64) ? 64
14134 : (reg_size == AFL_REG_128) ? 128
14135 : -1;
14136}
14137
19e6b90e 14138static int
2cf0635d 14139process_mips_specific (FILE * file)
5b18a4bc 14140{
2cf0635d 14141 Elf_Internal_Dyn * entry;
351cdf24 14142 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14143 size_t liblist_offset = 0;
14144 size_t liblistno = 0;
14145 size_t conflictsno = 0;
14146 size_t options_offset = 0;
14147 size_t conflicts_offset = 0;
861fb55a
DJ		 14148 size_t pltrelsz = 0;
14149 size_t pltrel = 0;
ccb4c951 14150 bfd_vma pltgot = 0;
861fb55a
DJ		 14151 bfd_vma mips_pltgot = 0;
14152 bfd_vma jmprel = 0;
ccb4c951
RS		 14153 bfd_vma local_gotno = 0;
14154 bfd_vma gotsym = 0;
14155 bfd_vma symtabno = 0;
103f02d3 14156
2cf19d5c
JM		 14157 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14158 display_mips_gnu_attribute);
14159
351cdf24
MF		 14160 sect = find_section (".MIPS.abiflags");
14161
14162 if (sect != NULL)
14163 {
14164 Elf_External_ABIFlags_v0 *abiflags_ext;
14165 Elf_Internal_ABIFlags_v0 abiflags_in;
14166
14167 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14168 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14169 else
14170 {
14171 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14172 sect->sh_size, _("MIPS ABI Flags section"));
14173 if (abiflags_ext)
14174 {
14175 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14176 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14177 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14178 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14179 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14180 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14181 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14182 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14183 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14184 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14185 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14186
14187 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14188 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14189 if (abiflags_in.isa_rev > 1)
14190 printf ("r%d", abiflags_in.isa_rev);
14191 printf ("\nGPR size: %d",
14192 get_mips_reg_size (abiflags_in.gpr_size));
14193 printf ("\nCPR1 size: %d",
14194 get_mips_reg_size (abiflags_in.cpr1_size));
14195 printf ("\nCPR2 size: %d",
14196 get_mips_reg_size (abiflags_in.cpr2_size));
14197 fputs ("\nFP ABI: ", stdout);
14198 print_mips_fp_abi_value (abiflags_in.fp_abi);
14199 fputs ("ISA Extension: ", stdout);
14200 print_mips_isa_ext (abiflags_in.isa_ext);
14201 fputs ("\nASEs:", stdout);
14202 print_mips_ases (abiflags_in.ases);
14203 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14204 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14205 fputc ('\n', stdout);
14206 free (abiflags_ext);
14207 }
14208 }
14209 }
14210
19e6b90e
L		 14211 /* We have a lot of special sections. Thanks SGI! */
14212 if (dynamic_section == NULL)
14213 /* No information available. */
14214 return 0;
252b5132 14215
071436c6
NC		 14216 for (entry = dynamic_section;
14217 /* PR 17531 file: 012-50589-0.004. */
14218 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14219 ++entry)
252b5132
RH		 14220 switch (entry->d_tag)
14221 {
14222 case DT_MIPS_LIBLIST:
d93f0186
NC		 14223 liblist_offset
14224 = offset_from_vma (file, entry->d_un.d_val,
14225 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14226 break;
14227 case DT_MIPS_LIBLISTNO:
14228 liblistno = entry->d_un.d_val;
14229 break;
14230 case DT_MIPS_OPTIONS:
d93f0186 14231 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14232 break;
14233 case DT_MIPS_CONFLICT:
d93f0186
NC		 14234 conflicts_offset
14235 = offset_from_vma (file, entry->d_un.d_val,
14236 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14237 break;
14238 case DT_MIPS_CONFLICTNO:
14239 conflictsno = entry->d_un.d_val;
14240 break;
ccb4c951 14241 case DT_PLTGOT:
861fb55a
DJ		 14242 pltgot = entry->d_un.d_ptr;
14243 break;
ccb4c951
RS		 14244 case DT_MIPS_LOCAL_GOTNO:
14245 local_gotno = entry->d_un.d_val;
14246 break;
14247 case DT_MIPS_GOTSYM:
14248 gotsym = entry->d_un.d_val;
14249 break;
14250 case DT_MIPS_SYMTABNO:
14251 symtabno = entry->d_un.d_val;
14252 break;
861fb55a
DJ		 14253 case DT_MIPS_PLTGOT:
14254 mips_pltgot = entry->d_un.d_ptr;
14255 break;
14256 case DT_PLTREL:
14257 pltrel = entry->d_un.d_val;
14258 break;
14259 case DT_PLTRELSZ:
14260 pltrelsz = entry->d_un.d_val;
14261 break;
14262 case DT_JMPREL:
14263 jmprel = entry->d_un.d_ptr;
14264 break;
252b5132
RH		 14265 default:
14266 break;
14267 }
14268
14269 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14270 {
2cf0635d 14271 Elf32_External_Lib * elib;
252b5132
RH		 14272 size_t cnt;
14273
3f5e193b
NC		 14274 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14275 liblistno,
14276 sizeof (Elf32_External_Lib),
9cf03b7e 14277 _("liblist section data"));
a6e9f9df 14278 if (elib)
252b5132 14279 {
2b692964 14280 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14281 (unsigned long) liblistno);
2b692964 14282 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14283 stdout);
14284
14285 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14286 {
a6e9f9df 14287 Elf32_Lib liblist;
91d6fa6a 14288 time_t atime;
a6e9f9df 14289 char timebuf[20];
2cf0635d 14290 struct tm * tmp;
a6e9f9df
AM		 14291
14292 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14293 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14294 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14295 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14296 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14297
91d6fa6a 14298 tmp = gmtime (&atime);
e9e44622
JJ		 14299 snprintf (timebuf, sizeof (timebuf),
14300 "%04u-%02u-%02uT%02u:%02u:%02u",
14301 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14302 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14303
31104126 14304 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14305 if (VALID_DYNAMIC_NAME (liblist.l_name))
14306 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14307 else
2b692964 14308 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14309 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14310 liblist.l_version);
a6e9f9df
AM		 14311
14312 if (liblist.l_flags == 0)
2b692964 14313 puts (_(" NONE"));
a6e9f9df
AM		 14314 else
14315 {
14316 static const struct
252b5132 14317 {
2cf0635d 14318 const char * name;
a6e9f9df 14319 int bit;
252b5132 14320 }
a6e9f9df
AM		 14321 l_flags_vals[] =
14322 {
14323 { " EXACT_MATCH", LL_EXACT_MATCH },
14324 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14325 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14326 { " EXPORTS", LL_EXPORTS },
14327 { " DELAY_LOAD", LL_DELAY_LOAD },
14328 { " DELTA", LL_DELTA }
14329 };
14330 int flags = liblist.l_flags;
14331 size_t fcnt;
14332
60bca95a 14333 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14334 if ((flags & l_flags_vals[fcnt].bit) != 0)
14335 {
14336 fputs (l_flags_vals[fcnt].name, stdout);
14337 flags ^= l_flags_vals[fcnt].bit;
14338 }
14339 if (flags != 0)
14340 printf (" %#x", (unsigned int) flags);
252b5132 14341
a6e9f9df
AM		 14342 puts ("");
14343 }
252b5132 14344 }
252b5132 14345
a6e9f9df
AM		 14346 free (elib);
14347 }
252b5132
RH		 14348 }
14349
14350 if (options_offset != 0)
14351 {
2cf0635d 14352 Elf_External_Options * eopt;
2cf0635d
NC		 14353 Elf_Internal_Options * iopt;
14354 Elf_Internal_Options * option;
252b5132
RH		 14355 size_t offset;
14356 int cnt;
351cdf24 14357 sect = section_headers;
252b5132
RH		 14358
14359 /* Find the section header so that we get the size. */
071436c6 14360 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14361 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14362 if (sect == NULL)
14363 {
14364 error (_("No MIPS_OPTIONS header found\n"));
14365 return 0;
14366 }
252b5132 14367
3f5e193b
NC		 14368 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14369 sect->sh_size, _("options"));
a6e9f9df 14370 if (eopt)
252b5132 14371 {
3f5e193b
NC		 14372 iopt = (Elf_Internal_Options *)
14373 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14374 if (iopt == NULL)
14375 {
8b73c356 14376 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14377 return 0;
14378 }
76da6bbe 14379
a6e9f9df
AM		 14380 offset = cnt = 0;
14381 option = iopt;
252b5132 14382
82b1b41b 14383 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14384 {
2cf0635d 14385 Elf_External_Options * eoption;
252b5132 14386
a6e9f9df 14387 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14388
a6e9f9df
AM		 14389 option->kind = BYTE_GET (eoption->kind);
14390 option->size = BYTE_GET (eoption->size);
14391 option->section = BYTE_GET (eoption->section);
14392 option->info = BYTE_GET (eoption->info);
76da6bbe 14393
82b1b41b
NC		 14394 /* PR 17531: file: ffa0fa3b. */
14395 if (option->size < sizeof (* eopt)
14396 || offset + option->size > sect->sh_size)
14397 {
55325047
NC		 14398 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14399 return 0;
82b1b41b 14400 }
a6e9f9df 14401 offset += option->size;
14ae95f2 14402
a6e9f9df
AM		 14403 ++option;
14404 ++cnt;
14405 }
252b5132 14406
a6e9f9df 14407 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14408 printable_section_name (sect), cnt);
76da6bbe 14409
a6e9f9df 14410 option = iopt;
82b1b41b 14411 offset = 0;
252b5132 14412
a6e9f9df 14413 while (cnt-- > 0)
252b5132 14414 {
a6e9f9df
AM		 14415 size_t len;
14416
14417 switch (option->kind)
252b5132 14418 {
a6e9f9df
AM		 14419 case ODK_NULL:
14420 /* This shouldn't happen. */
14421 printf (" NULL %d %lx", option->section, option->info);
14422 break;
14423 case ODK_REGINFO:
14424 printf (" REGINFO ");
14425 if (elf_header.e_machine == EM_MIPS)
14426 {
14427 /* 32bit form. */
2cf0635d 14428 Elf32_External_RegInfo * ereg;
b34976b6 14429 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14430
14431 ereg = (Elf32_External_RegInfo *) (option + 1);
14432 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14433 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14434 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14435 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14436 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14437 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14438
14439 printf ("GPR %08lx GP 0x%lx\n",
14440 reginfo.ri_gprmask,
14441 (unsigned long) reginfo.ri_gp_value);
14442 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14443 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14444 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14445 }
14446 else
14447 {
14448 /* 64 bit form. */
2cf0635d 14449 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14450 Elf64_Internal_RegInfo reginfo;
14451
14452 ereg = (Elf64_External_RegInfo *) (option + 1);
14453 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14454 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14455 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14456 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14457 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14458 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14459
14460 printf ("GPR %08lx GP 0x",
14461 reginfo.ri_gprmask);
14462 printf_vma (reginfo.ri_gp_value);
14463 printf ("\n");
14464
14465 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14466 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14467 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14468 }
14469 ++option;
14470 continue;
14471 case ODK_EXCEPTIONS:
14472 fputs (" EXCEPTIONS fpe_min(", stdout);
14473 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14474 fputs (") fpe_max(", stdout);
14475 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14476 fputs (")", stdout);
14477
14478 if (option->info & OEX_PAGE0)
14479 fputs (" PAGE0", stdout);
14480 if (option->info & OEX_SMM)
14481 fputs (" SMM", stdout);
14482 if (option->info & OEX_FPDBUG)
14483 fputs (" FPDBUG", stdout);
14484 if (option->info & OEX_DISMISS)
14485 fputs (" DISMISS", stdout);
14486 break;
14487 case ODK_PAD:
14488 fputs (" PAD ", stdout);
14489 if (option->info & OPAD_PREFIX)
14490 fputs (" PREFIX", stdout);
14491 if (option->info & OPAD_POSTFIX)
14492 fputs (" POSTFIX", stdout);
14493 if (option->info & OPAD_SYMBOL)
14494 fputs (" SYMBOL", stdout);
14495 break;
14496 case ODK_HWPATCH:
14497 fputs (" HWPATCH ", stdout);
14498 if (option->info & OHW_R4KEOP)
14499 fputs (" R4KEOP", stdout);
14500 if (option->info & OHW_R8KPFETCH)
14501 fputs (" R8KPFETCH", stdout);
14502 if (option->info & OHW_R5KEOP)
14503 fputs (" R5KEOP", stdout);
14504 if (option->info & OHW_R5KCVTL)
14505 fputs (" R5KCVTL", stdout);
14506 break;
14507 case ODK_FILL:
14508 fputs (" FILL ", stdout);
14509 /* XXX Print content of info word? */
14510 break;
14511 case ODK_TAGS:
14512 fputs (" TAGS ", stdout);
14513 /* XXX Print content of info word? */
14514 break;
14515 case ODK_HWAND:
14516 fputs (" HWAND ", stdout);
14517 if (option->info & OHWA0_R4KEOP_CHECKED)
14518 fputs (" R4KEOP_CHECKED", stdout);
14519 if (option->info & OHWA0_R4KEOP_CLEAN)
14520 fputs (" R4KEOP_CLEAN", stdout);
14521 break;
14522 case ODK_HWOR:
14523 fputs (" HWOR ", stdout);
14524 if (option->info & OHWA0_R4KEOP_CHECKED)
14525 fputs (" R4KEOP_CHECKED", stdout);
14526 if (option->info & OHWA0_R4KEOP_CLEAN)
14527 fputs (" R4KEOP_CLEAN", stdout);
14528 break;
14529 case ODK_GP_GROUP:
14530 printf (" GP_GROUP %#06lx self-contained %#06lx",
14531 option->info & OGP_GROUP,
14532 (option->info & OGP_SELF) >> 16);
14533 break;
14534 case ODK_IDENT:
14535 printf (" IDENT %#06lx self-contained %#06lx",
14536 option->info & OGP_GROUP,
14537 (option->info & OGP_SELF) >> 16);
14538 break;
14539 default:
14540 /* This shouldn't happen. */
14541 printf (" %3d ??? %d %lx",
14542 option->kind, option->section, option->info);
14543 break;
252b5132 14544 }
a6e9f9df 14545
2cf0635d 14546 len = sizeof (* eopt);
a6e9f9df 14547 while (len < option->size)
82b1b41b 14548 {
7e27a9d5 14549 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14550
82b1b41b
NC		 14551 if (ISPRINT (datum))
14552 printf ("%c", datum);
14553 else
14554 printf ("\\%03o", datum);
14555 len ++;
14556 }
a6e9f9df 14557 fputs ("\n", stdout);
82b1b41b
NC		 14558
14559 offset += option->size;
252b5132 14560 ++option;
252b5132
RH		 14561 }
14562
a6e9f9df 14563 free (eopt);
252b5132 14564 }
252b5132
RH		 14565 }
14566
14567 if (conflicts_offset != 0 && conflictsno != 0)
14568 {
2cf0635d 14569 Elf32_Conflict * iconf;
252b5132
RH		 14570 size_t cnt;
14571
14572 if (dynamic_symbols == NULL)
14573 {
591a748a 14574 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14575 return 0;
14576 }
14577
3f5e193b 14578 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14579 if (iconf == NULL)
14580 {
8b73c356 14581 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14582 return 0;
14583 }
14584
9ea033b2 14585 if (is_32bit_elf)
252b5132 14586 {
2cf0635d 14587 Elf32_External_Conflict * econf32;
a6e9f9df 14588
3f5e193b
NC		 14589 econf32 = (Elf32_External_Conflict *)
14590 get_data (NULL, file, conflicts_offset, conflictsno,
14591 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14592 if (!econf32)
14593 return 0;
252b5132
RH		 14594
14595 for (cnt = 0; cnt < conflictsno; ++cnt)
14596 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14597
14598 free (econf32);
252b5132
RH		 14599 }
14600 else
14601 {
2cf0635d 14602 Elf64_External_Conflict * econf64;
a6e9f9df 14603
3f5e193b
NC		 14604 econf64 = (Elf64_External_Conflict *)
14605 get_data (NULL, file, conflicts_offset, conflictsno,
14606 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14607 if (!econf64)
14608 return 0;
252b5132
RH		 14609
14610 for (cnt = 0; cnt < conflictsno; ++cnt)
14611 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14612
14613 free (econf64);
252b5132
RH		 14614 }
14615
c7e7ca54
NC		 14616 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14617 (unsigned long) conflictsno);
252b5132
RH		 14618 puts (_(" Num: Index Value Name"));
14619
14620 for (cnt = 0; cnt < conflictsno; ++cnt)
14621 {
b34976b6 14622 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14623
14624 if (iconf[cnt] >= num_dynamic_syms)
14625 printf (_("<corrupt symbol index>"));
d79b3d50 14626 else
e0a31db1
NC		 14627 {
14628 Elf_Internal_Sym * psym;
14629
14630 psym = & dynamic_symbols[iconf[cnt]];
14631 print_vma (psym->st_value, FULL_HEX);
14632 putchar (' ');
14633 if (VALID_DYNAMIC_NAME (psym->st_name))
14634 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14635 else
14636 printf (_("<corrupt: %14ld>"), psym->st_name);
14637 }
31104126 14638 putchar ('\n');
252b5132
RH		 14639 }
14640
252b5132
RH		 14641 free (iconf);
14642 }
14643
ccb4c951
RS		 14644 if (pltgot != 0 && local_gotno != 0)
14645 {
91d6fa6a 14646 bfd_vma ent, local_end, global_end;
bbeee7ea 14647 size_t i, offset;
2cf0635d 14648 unsigned char * data;
82b1b41b 14649 unsigned char * data_end;
bbeee7ea 14650 int addr_size;
ccb4c951 14651
91d6fa6a 14652 ent = pltgot;
ccb4c951
RS		 14653 addr_size = (is_32bit_elf ? 4 : 8);
14654 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14655
74e1a04b
NC		 14656 /* PR binutils/17533 file: 012-111227-0.004 */
14657 if (symtabno < gotsym)
14658 {
14659 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14660 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14661 return 0;
14662 }
82b1b41b 14663
74e1a04b 14664 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14665 /* PR 17531: file: 54c91a34. */
14666 if (global_end < local_end)
14667 {
14668 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14669 return 0;
14670 }
948f632f 14671
ccb4c951 14672 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14673 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14674 global_end - pltgot, 1,
14675 _("Global Offset Table data"));
59245841
NC		 14676 if (data == NULL)
14677 return 0;
82b1b41b 14678 data_end = data + (global_end - pltgot);
59245841 14679
ccb4c951
RS		 14680 printf (_("\nPrimary GOT:\n"));
14681 printf (_(" Canonical gp value: "));
14682 print_vma (pltgot + 0x7ff0, LONG_HEX);
14683 printf ("\n\n");
14684
14685 printf (_(" Reserved entries:\n"));
14686 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14687 addr_size * 2, _("Address"), _("Access"),
14688 addr_size * 2, _("Initial"));
82b1b41b 14689 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14690 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14691 if (ent == (bfd_vma) -1)
14692 goto got_print_fail;
ccb4c951 14693 if (data
91d6fa6a 14694 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14695 >> (addr_size * 8 - 1)) != 0)
14696 {
82b1b41b 14697 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14698 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14699 if (ent == (bfd_vma) -1)
14700 goto got_print_fail;
ccb4c951
RS		 14701 }
14702 printf ("\n");
14703
91d6fa6a 14704 if (ent < local_end)
ccb4c951
RS		 14705 {
14706 printf (_(" Local entries:\n"));
cc5914eb 14707 printf (" %*s %10s %*s\n",
2b692964
NC		 14708 addr_size * 2, _("Address"), _("Access"),
14709 addr_size * 2, _("Initial"));
91d6fa6a 14710 while (ent < local_end)
ccb4c951 14711 {
82b1b41b 14712 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14713 printf ("\n");
82b1b41b
NC		 14714 if (ent == (bfd_vma) -1)
14715 goto got_print_fail;
ccb4c951
RS		 14716 }
14717 printf ("\n");
14718 }
14719
14720 if (gotsym < symtabno)
14721 {
14722 int sym_width;
14723
14724 printf (_(" Global entries:\n"));
cc5914eb 14725 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14726 addr_size * 2, _("Address"),
14727 _("Access"),
2b692964 14728 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14729 addr_size * 2, _("Sym.Val."),
14730 _("Type"),
14731 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14732 _("Ndx"), _("Name"));
0b4362b0 14733
ccb4c951 14734 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14735
ccb4c951
RS		 14736 for (i = gotsym; i < symtabno; i++)
14737 {
82b1b41b 14738 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14739 printf (" ");
e0a31db1
NC		 14740
14741 if (dynamic_symbols == NULL)
14742 printf (_("<no dynamic symbols>"));
14743 else if (i < num_dynamic_syms)
14744 {
14745 Elf_Internal_Sym * psym = dynamic_symbols + i;
14746
14747 print_vma (psym->st_value, LONG_HEX);
14748 printf (" %-7s %3s ",
14749 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14750 get_symbol_index_type (psym->st_shndx));
14751
14752 if (VALID_DYNAMIC_NAME (psym->st_name))
14753 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14754 else
14755 printf (_("<corrupt: %14ld>"), psym->st_name);
14756 }
ccb4c951 14757 else
7fc5ac57
JBG		 14758 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14759 (unsigned long) i);
e0a31db1 14760
ccb4c951 14761 printf ("\n");
82b1b41b
NC		 14762 if (ent == (bfd_vma) -1)
14763 break;
ccb4c951
RS		 14764 }
14765 printf ("\n");
14766 }
14767
82b1b41b 14768 got_print_fail:
ccb4c951
RS		 14769 if (data)
14770 free (data);
14771 }
14772
861fb55a
DJ		 14773 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14774 {
91d6fa6a 14775 bfd_vma ent, end;
861fb55a
DJ		 14776 size_t offset, rel_offset;
14777 unsigned long count, i;
2cf0635d 14778 unsigned char * data;
861fb55a 14779 int addr_size, sym_width;
2cf0635d 14780 Elf_Internal_Rela * rels;
861fb55a
DJ		 14781
14782 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14783 if (pltrel == DT_RELA)
14784 {
14785 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14786 return 0;
14787 }
14788 else
14789 {
14790 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14791 return 0;
14792 }
14793
91d6fa6a 14794 ent = mips_pltgot;
861fb55a
DJ		 14795 addr_size = (is_32bit_elf ? 4 : 8);
14796 end = mips_pltgot + (2 + count) * addr_size;
14797
14798 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14799 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14800 1, _("Procedure Linkage Table data"));
59245841
NC		 14801 if (data == NULL)
14802 return 0;
14803
9cf03b7e 14804 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14805 printf (_(" Reserved entries:\n"));
14806 printf (_(" %*s %*s Purpose\n"),
2b692964 14807 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14808 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14809 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14810 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14811 printf (_(" Module pointer\n"));
861fb55a
DJ		 14812 printf ("\n");
14813
14814 printf (_(" Entries:\n"));
cc5914eb 14815 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14816 addr_size * 2, _("Address"),
14817 addr_size * 2, _("Initial"),
14818 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14819 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14820 for (i = 0; i < count; i++)
14821 {
df97ab2a 14822 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14823
91d6fa6a 14824 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14825 printf (" ");
e0a31db1 14826
df97ab2a
MF		 14827 if (idx >= num_dynamic_syms)
14828 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14829 else
e0a31db1 14830 {
df97ab2a 14831 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14832
14833 print_vma (psym->st_value, LONG_HEX);
14834 printf (" %-7s %3s ",
14835 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14836 get_symbol_index_type (psym->st_shndx));
14837 if (VALID_DYNAMIC_NAME (psym->st_name))
14838 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14839 else
14840 printf (_("<corrupt: %14ld>"), psym->st_name);
14841 }
861fb55a
DJ		 14842 printf ("\n");
14843 }
14844 printf ("\n");
14845
14846 if (data)
14847 free (data);
14848 free (rels);
14849 }
14850
252b5132
RH		 14851 return 1;
14852}
14853
35c08157
KLC		 14854static int
14855process_nds32_specific (FILE * file)
14856{
14857 Elf_Internal_Shdr *sect = NULL;
14858
14859 sect = find_section (".nds32_e_flags");
14860 if (sect != NULL)
14861 {
14862 unsigned int *flag;
14863
14864 printf ("\nNDS32 elf flags section:\n");
14865 flag = get_data (NULL, file, sect->sh_offset, 1,
14866 sect->sh_size, _("NDS32 elf flags section"));
14867
14868 switch ((*flag) & 0x3)
14869 {
14870 case 0:
14871 printf ("(VEC_SIZE):\tNo entry.\n");
14872 break;
14873 case 1:
14874 printf ("(VEC_SIZE):\t4 bytes\n");
14875 break;
14876 case 2:
14877 printf ("(VEC_SIZE):\t16 bytes\n");
14878 break;
14879 case 3:
14880 printf ("(VEC_SIZE):\treserved\n");
14881 break;
14882 }
14883 }
14884
14885 return TRUE;
14886}
14887
047b2264 14888static int
2cf0635d 14889process_gnu_liblist (FILE * file)
047b2264 14890{
2cf0635d
NC		 14891 Elf_Internal_Shdr * section;
14892 Elf_Internal_Shdr * string_sec;
14893 Elf32_External_Lib * elib;
14894 char * strtab;
c256ffe7 14895 size_t strtab_size;
047b2264
JJ		 14896 size_t cnt;
14897 unsigned i;
14898
14899 if (! do_arch)
14900 return 0;
14901
14902 for (i = 0, section = section_headers;
14903 i < elf_header.e_shnum;
b34976b6 14904 i++, section++)
047b2264
JJ		 14905 {
14906 switch (section->sh_type)
14907 {
14908 case SHT_GNU_LIBLIST:
4fbb74a6 14909 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14910 break;
14911
3f5e193b
NC		 14912 elib = (Elf32_External_Lib *)
14913 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14914 _("liblist section data"));
047b2264
JJ		 14915
14916 if (elib == NULL)
14917 break;
4fbb74a6 14918 string_sec = section_headers + section->sh_link;
047b2264 14919
3f5e193b
NC		 14920 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14921 string_sec->sh_size,
14922 _("liblist string table"));
047b2264
JJ		 14923 if (strtab == NULL
14924 || section->sh_entsize != sizeof (Elf32_External_Lib))
14925 {
14926 free (elib);
2842702f 14927 free (strtab);
047b2264
JJ		 14928 break;
14929 }
59245841 14930 strtab_size = string_sec->sh_size;
047b2264
JJ		 14931
14932 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14933 printable_section_name (section),
0af1713e 14934 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14935
2b692964 14936 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14937
14938 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14939 ++cnt)
14940 {
14941 Elf32_Lib liblist;
91d6fa6a 14942 time_t atime;
047b2264 14943 char timebuf[20];
2cf0635d 14944 struct tm * tmp;
047b2264
JJ		 14945
14946 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14947 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14948 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14949 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14950 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14951
91d6fa6a 14952 tmp = gmtime (&atime);
e9e44622
JJ		 14953 snprintf (timebuf, sizeof (timebuf),
14954 "%04u-%02u-%02uT%02u:%02u:%02u",
14955 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14956 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14957
14958 printf ("%3lu: ", (unsigned long) cnt);
14959 if (do_wide)
c256ffe7 14960 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14961 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14962 else
c256ffe7 14963 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14964 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14965 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14966 liblist.l_version, liblist.l_flags);
14967 }
14968
14969 free (elib);
2842702f 14970 free (strtab);
047b2264
JJ		 14971 }
14972 }
14973
14974 return 1;
14975}
14976
9437c45b 14977static const char *
d3ba0551 14978get_note_type (unsigned e_type)
779fe533
NC		 14979{
14980 static char buff[64];
103f02d3 14981
1ec5cd37
NC		 14982 if (elf_header.e_type == ET_CORE)
14983 switch (e_type)
14984 {
57346661 14985 case NT_AUXV:
1ec5cd37 14986 return _("NT_AUXV (auxiliary vector)");
57346661 14987 case NT_PRSTATUS:
1ec5cd37 14988 return _("NT_PRSTATUS (prstatus structure)");
57346661 14989 case NT_FPREGSET:
1ec5cd37 14990 return _("NT_FPREGSET (floating point registers)");
57346661 14991 case NT_PRPSINFO:
1ec5cd37 14992 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 14993 case NT_TASKSTRUCT:
1ec5cd37 14994 return _("NT_TASKSTRUCT (task structure)");
57346661 14995 case NT_PRXFPREG:
1ec5cd37 14996 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 14997 case NT_PPC_VMX:
14998 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 14999 case NT_PPC_VSX:
15000 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15001 case NT_386_TLS:
15002 return _("NT_386_TLS (x86 TLS information)");
15003 case NT_386_IOPERM:
15004 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15005 case NT_X86_XSTATE:
15006 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15007 case NT_S390_HIGH_GPRS:
15008 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15009 case NT_S390_TIMER:
15010 return _("NT_S390_TIMER (s390 timer register)");
15011 case NT_S390_TODCMP:
15012 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15013 case NT_S390_TODPREG:
15014 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15015 case NT_S390_CTRS:
15016 return _("NT_S390_CTRS (s390 control registers)");
15017 case NT_S390_PREFIX:
15018 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15019 case NT_S390_LAST_BREAK:
15020 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15021 case NT_S390_SYSTEM_CALL:
15022 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15023 case NT_S390_TDB:
15024 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15025 case NT_S390_VXRS_LOW:
15026 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15027 case NT_S390_VXRS_HIGH:
15028 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15029 case NT_ARM_VFP:
15030 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15031 case NT_ARM_TLS:
15032 return _("NT_ARM_TLS (AArch TLS registers)");
15033 case NT_ARM_HW_BREAK:
15034 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15035 case NT_ARM_HW_WATCH:
15036 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15037 case NT_PSTATUS:
1ec5cd37 15038 return _("NT_PSTATUS (pstatus structure)");
57346661 15039 case NT_FPREGS:
1ec5cd37 15040 return _("NT_FPREGS (floating point registers)");
57346661 15041 case NT_PSINFO:
1ec5cd37 15042 return _("NT_PSINFO (psinfo structure)");
57346661 15043 case NT_LWPSTATUS:
1ec5cd37 15044 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15045 case NT_LWPSINFO:
1ec5cd37 15046 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15047 case NT_WIN32PSTATUS:
1ec5cd37 15048 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15049 case NT_SIGINFO:
15050 return _("NT_SIGINFO (siginfo_t data)");
15051 case NT_FILE:
15052 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15053 default:
15054 break;
15055 }
15056 else
15057 switch (e_type)
15058 {
15059 case NT_VERSION:
15060 return _("NT_VERSION (version)");
15061 case NT_ARCH:
15062 return _("NT_ARCH (architecture)");
15063 default:
15064 break;
15065 }
15066
e9e44622 15067 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15068 return buff;
779fe533
NC		 15069}
15070
9ece1fa9
TT		 15071static int
15072print_core_note (Elf_Internal_Note *pnote)
15073{
15074 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15075 bfd_vma count, page_size;
15076 unsigned char *descdata, *filenames, *descend;
15077
15078 if (pnote->type != NT_FILE)
15079 return 1;
15080
15081#ifndef BFD64
15082 if (!is_32bit_elf)
15083 {
15084 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15085 /* Still "successful". */
15086 return 1;
15087 }
15088#endif
15089
15090 if (pnote->descsz < 2 * addr_size)
15091 {
15092 printf (_(" Malformed note - too short for header\n"));
15093 return 0;
15094 }
15095
15096 descdata = (unsigned char *) pnote->descdata;
15097 descend = descdata + pnote->descsz;
15098
15099 if (descdata[pnote->descsz - 1] != '\0')
15100 {
15101 printf (_(" Malformed note - does not end with \\0\n"));
15102 return 0;
15103 }
15104
15105 count = byte_get (descdata, addr_size);
15106 descdata += addr_size;
15107
15108 page_size = byte_get (descdata, addr_size);
15109 descdata += addr_size;
15110
15111 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15112 {
15113 printf (_(" Malformed note - too short for supplied file count\n"));
15114 return 0;
15115 }
15116
15117 printf (_(" Page size: "));
15118 print_vma (page_size, DEC);
15119 printf ("\n");
15120
15121 printf (_(" %*s%*s%*s\n"),
15122 (int) (2 + 2 * addr_size), _("Start"),
15123 (int) (4 + 2 * addr_size), _("End"),
15124 (int) (4 + 2 * addr_size), _("Page Offset"));
15125 filenames = descdata + count * 3 * addr_size;
595712bb 15126 while (count-- > 0)
9ece1fa9
TT		 15127 {
15128 bfd_vma start, end, file_ofs;
15129
15130 if (filenames == descend)
15131 {
15132 printf (_(" Malformed note - filenames end too early\n"));
15133 return 0;
15134 }
15135
15136 start = byte_get (descdata, addr_size);
15137 descdata += addr_size;
15138 end = byte_get (descdata, addr_size);
15139 descdata += addr_size;
15140 file_ofs = byte_get (descdata, addr_size);
15141 descdata += addr_size;
15142
15143 printf (" ");
15144 print_vma (start, FULL_HEX);
15145 printf (" ");
15146 print_vma (end, FULL_HEX);
15147 printf (" ");
15148 print_vma (file_ofs, FULL_HEX);
15149 printf ("\n %s\n", filenames);
15150
15151 filenames += 1 + strlen ((char *) filenames);
15152 }
15153
15154 return 1;
15155}
15156
1118d252
RM		 15157static const char *
15158get_gnu_elf_note_type (unsigned e_type)
15159{
15160 static char buff[64];
15161
15162 switch (e_type)
15163 {
15164 case NT_GNU_ABI_TAG:
15165 return _("NT_GNU_ABI_TAG (ABI version tag)");
15166 case NT_GNU_HWCAP:
15167 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15168 case NT_GNU_BUILD_ID:
15169 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15170 case NT_GNU_GOLD_VERSION:
15171 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15172 default:
15173 break;
15174 }
15175
15176 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15177 return buff;
15178}
15179
664f90a3
TT		 15180static int
15181print_gnu_note (Elf_Internal_Note *pnote)
15182{
15183 switch (pnote->type)
15184 {
15185 case NT_GNU_BUILD_ID:
15186 {
15187 unsigned long i;
15188
15189 printf (_(" Build ID: "));
15190 for (i = 0; i < pnote->descsz; ++i)
15191 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15192 printf ("\n");
664f90a3
TT		 15193 }
15194 break;
15195
15196 case NT_GNU_ABI_TAG:
15197 {
15198 unsigned long os, major, minor, subminor;
15199 const char *osname;
15200
3102e897
NC		 15201 /* PR 17531: file: 030-599401-0.004. */
15202 if (pnote->descsz < 16)
15203 {
15204 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15205 break;
15206 }
15207
664f90a3
TT		 15208 os = byte_get ((unsigned char *) pnote->descdata, 4);
15209 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15210 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15211 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15212
15213 switch (os)
15214 {
15215 case GNU_ABI_TAG_LINUX:
15216 osname = "Linux";
15217 break;
15218 case GNU_ABI_TAG_HURD:
15219 osname = "Hurd";
15220 break;
15221 case GNU_ABI_TAG_SOLARIS:
15222 osname = "Solaris";
15223 break;
15224 case GNU_ABI_TAG_FREEBSD:
15225 osname = "FreeBSD";
15226 break;
15227 case GNU_ABI_TAG_NETBSD:
15228 osname = "NetBSD";
15229 break;
14ae95f2
RM		 15230 case GNU_ABI_TAG_SYLLABLE:
15231 osname = "Syllable";
15232 break;
15233 case GNU_ABI_TAG_NACL:
15234 osname = "NaCl";
15235 break;
664f90a3
TT		 15236 default:
15237 osname = "Unknown";
15238 break;
15239 }
15240
15241 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15242 major, minor, subminor);
15243 }
15244 break;
926c5385
CC		 15245
15246 case NT_GNU_GOLD_VERSION:
15247 {
15248 unsigned long i;
15249
15250 printf (_(" Version: "));
15251 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15252 printf ("%c", pnote->descdata[i]);
15253 printf ("\n");
15254 }
15255 break;
664f90a3
TT		 15256 }
15257
15258 return 1;
15259}
15260
685080f2
NC		 15261static const char *
15262get_v850_elf_note_type (enum v850_notes n_type)
15263{
15264 static char buff[64];
15265
15266 switch (n_type)
15267 {
15268 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15269 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15270 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15271 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15272 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15273 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15274 default:
15275 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15276 return buff;
15277 }
15278}
15279
15280static int
15281print_v850_note (Elf_Internal_Note * pnote)
15282{
15283 unsigned int val;
15284
15285 if (pnote->descsz != 4)
15286 return 0;
15287 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15288
15289 if (val == 0)
15290 {
15291 printf (_("not set\n"));
15292 return 1;
15293 }
15294
15295 switch (pnote->type)
15296 {
15297 case V850_NOTE_ALIGNMENT:
15298 switch (val)
15299 {
15300 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15301 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15302 }
15303 break;
14ae95f2 15304
685080f2
NC		 15305 case V850_NOTE_DATA_SIZE:
15306 switch (val)
15307 {
15308 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15309 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15310 }
15311 break;
14ae95f2 15312
685080f2
NC		 15313 case V850_NOTE_FPU_INFO:
15314 switch (val)
15315 {
15316 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15317 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15318 }
15319 break;
14ae95f2 15320
685080f2
NC		 15321 case V850_NOTE_MMU_INFO:
15322 case V850_NOTE_CACHE_INFO:
15323 case V850_NOTE_SIMD_INFO:
15324 if (val == EF_RH850_SIMD)
15325 {
15326 printf (_("yes\n"));
15327 return 1;
15328 }
15329 break;
15330
15331 default:
15332 /* An 'unknown note type' message will already have been displayed. */
15333 break;
15334 }
15335
15336 printf (_("unknown value: %x\n"), val);
15337 return 0;
15338}
15339
c6056a74
SF		 15340static int
15341process_netbsd_elf_note (Elf_Internal_Note * pnote)
15342{
15343 unsigned int version;
15344
15345 switch (pnote->type)
15346 {
15347 case NT_NETBSD_IDENT:
15348 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15349 if ((version / 10000) % 100)
15350 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15351 version, version / 100000000, (version / 1000000) % 100,
15352 (version / 10000) % 100 > 26 ? "Z" : "",
15353 'A' + (version / 10000) % 26);
15354 else
15355 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15356 version, version / 100000000, (version / 1000000) % 100,
15357 (version / 100) % 100);
15358 return 1;
15359
15360 case NT_NETBSD_MARCH:
15361 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15362 pnote->descdata);
15363 return 1;
15364
15365 default:
15366 break;
15367 }
15368
15369 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15370 pnote->type);
15371 return 1;
15372}
15373
9437c45b 15374static const char *
d3ba0551 15375get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15376{
15377 static char buff[64];
15378
b4db1224 15379 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15380 {
15381 /* NetBSD core "procinfo" structure. */
15382 return _("NetBSD procinfo structure");
15383 }
15384
15385 /* As of Jan 2002 there are no other machine-independent notes
15386 defined for NetBSD core files. If the note type is less
15387 than the start of the machine-dependent note types, we don't
15388 understand it. */
15389
b4db1224 15390 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15391 {
e9e44622 15392 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15393 return buff;
15394 }
15395
15396 switch (elf_header.e_machine)
15397 {
15398 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15399 and PT_GETFPREGS == mach+2. */
15400
15401 case EM_OLD_ALPHA:
15402 case EM_ALPHA:
15403 case EM_SPARC:
15404 case EM_SPARC32PLUS:
15405 case EM_SPARCV9:
15406 switch (e_type)
15407 {
2b692964 15408 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15409 return _("PT_GETREGS (reg structure)");
2b692964 15410 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15411 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15412 default:
15413 break;
15414 }
15415 break;
15416
15417 /* On all other arch's, PT_GETREGS == mach+1 and
15418 PT_GETFPREGS == mach+3. */
15419 default:
15420 switch (e_type)
15421 {
2b692964 15422 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15423 return _("PT_GETREGS (reg structure)");
2b692964 15424 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15425 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15426 default:
15427 break;
15428 }
15429 }
15430
9cf03b7e 15431 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15432 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15433 return buff;
15434}
15435
70616151
TT		 15436static const char *
15437get_stapsdt_note_type (unsigned e_type)
15438{
15439 static char buff[64];
15440
15441 switch (e_type)
15442 {
15443 case NT_STAPSDT:
15444 return _("NT_STAPSDT (SystemTap probe descriptors)");
15445
15446 default:
15447 break;
15448 }
15449
15450 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15451 return buff;
15452}
15453
c6a9fc58
TT		 15454static int
15455print_stapsdt_note (Elf_Internal_Note *pnote)
15456{
15457 int addr_size = is_32bit_elf ? 4 : 8;
15458 char *data = pnote->descdata;
15459 char *data_end = pnote->descdata + pnote->descsz;
15460 bfd_vma pc, base_addr, semaphore;
15461 char *provider, *probe, *arg_fmt;
15462
15463 pc = byte_get ((unsigned char *) data, addr_size);
15464 data += addr_size;
15465 base_addr = byte_get ((unsigned char *) data, addr_size);
15466 data += addr_size;
15467 semaphore = byte_get ((unsigned char *) data, addr_size);
15468 data += addr_size;
15469
15470 provider = data;
15471 data += strlen (data) + 1;
15472 probe = data;
15473 data += strlen (data) + 1;
15474 arg_fmt = data;
15475 data += strlen (data) + 1;
15476
15477 printf (_(" Provider: %s\n"), provider);
15478 printf (_(" Name: %s\n"), probe);
15479 printf (_(" Location: "));
15480 print_vma (pc, FULL_HEX);
15481 printf (_(", Base: "));
15482 print_vma (base_addr, FULL_HEX);
15483 printf (_(", Semaphore: "));
15484 print_vma (semaphore, FULL_HEX);
9cf03b7e 15485 printf ("\n");
c6a9fc58
TT		 15486 printf (_(" Arguments: %s\n"), arg_fmt);
15487
15488 return data == data_end;
15489}
15490
00e98fc7
TG		 15491static const char *
15492get_ia64_vms_note_type (unsigned e_type)
15493{
15494 static char buff[64];
15495
15496 switch (e_type)
15497 {
15498 case NT_VMS_MHD:
15499 return _("NT_VMS_MHD (module header)");
15500 case NT_VMS_LNM:
15501 return _("NT_VMS_LNM (language name)");
15502 case NT_VMS_SRC:
15503 return _("NT_VMS_SRC (source files)");
15504 case NT_VMS_TITLE:
9cf03b7e 15505 return "NT_VMS_TITLE";
00e98fc7
TG		 15506 case NT_VMS_EIDC:
15507 return _("NT_VMS_EIDC (consistency check)");
15508 case NT_VMS_FPMODE:
15509 return _("NT_VMS_FPMODE (FP mode)");
15510 case NT_VMS_LINKTIME:
9cf03b7e 15511 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15512 case NT_VMS_IMGNAM:
15513 return _("NT_VMS_IMGNAM (image name)");
15514 case NT_VMS_IMGID:
15515 return _("NT_VMS_IMGID (image id)");
15516 case NT_VMS_LINKID:
15517 return _("NT_VMS_LINKID (link id)");
15518 case NT_VMS_IMGBID:
15519 return _("NT_VMS_IMGBID (build id)");
15520 case NT_VMS_GSTNAM:
15521 return _("NT_VMS_GSTNAM (sym table name)");
15522 case NT_VMS_ORIG_DYN:
9cf03b7e 15523 return "NT_VMS_ORIG_DYN";
00e98fc7 15524 case NT_VMS_PATCHTIME:
9cf03b7e 15525 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15526 default:
15527 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15528 return buff;
15529 }
15530}
15531
15532static int
15533print_ia64_vms_note (Elf_Internal_Note * pnote)
15534{
15535 switch (pnote->type)
15536 {
15537 case NT_VMS_MHD:
15538 if (pnote->descsz > 36)
15539 {
15540 size_t l = strlen (pnote->descdata + 34);
15541 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15542 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15543 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15544 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15545 }
15546 else
15547 printf (_(" Invalid size\n"));
15548 break;
15549 case NT_VMS_LNM:
15550 printf (_(" Language: %s\n"), pnote->descdata);
15551 break;
15552#ifdef BFD64
15553 case NT_VMS_FPMODE:
9cf03b7e 15554 printf (_(" Floating Point mode: "));
4a5cb34f 15555 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15556 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15557 break;
15558 case NT_VMS_LINKTIME:
15559 printf (_(" Link time: "));
15560 print_vms_time
15561 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15562 printf ("\n");
15563 break;
15564 case NT_VMS_PATCHTIME:
15565 printf (_(" Patch time: "));
15566 print_vms_time
15567 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15568 printf ("\n");
15569 break;
15570 case NT_VMS_ORIG_DYN:
15571 printf (_(" Major id: %u, minor id: %u\n"),
15572 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15573 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15574 printf (_(" Last modified : "));
00e98fc7
TG		 15575 print_vms_time
15576 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15577 printf (_("\n Link flags : "));
4a5cb34f 15578 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15579 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15580 printf (_(" Header flags: 0x%08x\n"),
948f632f 15581 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15582 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15583 break;
15584#endif
15585 case NT_VMS_IMGNAM:
15586 printf (_(" Image name: %s\n"), pnote->descdata);
15587 break;
15588 case NT_VMS_GSTNAM:
15589 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15590 break;
15591 case NT_VMS_IMGID:
15592 printf (_(" Image id: %s\n"), pnote->descdata);
15593 break;
15594 case NT_VMS_LINKID:
15595 printf (_(" Linker id: %s\n"), pnote->descdata);
15596 break;
15597 default:
15598 break;
15599 }
15600 return 1;
15601}
15602
6d118b09
NC		 15603/* Note that by the ELF standard, the name field is already null byte
15604 terminated, and namesz includes the terminating null byte.
15605 I.E. the value of namesz for the name "FSF" is 4.
15606
e3c8793a 15607 If the value of namesz is zero, there is no name present. */
779fe533 15608static int
2cf0635d 15609process_note (Elf_Internal_Note * pnote)
779fe533 15610{
2cf0635d
NC		 15611 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15612 const char * nt;
9437c45b
JT		 15613
15614 if (pnote->namesz == 0)
1ec5cd37
NC		 15615 /* If there is no note name, then use the default set of
15616 note type strings. */
15617 nt = get_note_type (pnote->type);
15618
1118d252
RM		 15619 else if (const_strneq (pnote->namedata, "GNU"))
15620 /* GNU-specific object file notes. */
15621 nt = get_gnu_elf_note_type (pnote->type);
15622
0112cd26 15623 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15624 /* NetBSD-specific core file notes. */
15625 nt = get_netbsd_elfcore_note_type (pnote->type);
15626
c6056a74
SF		 15627 else if (const_strneq (pnote->namedata, "NetBSD"))
15628 /* NetBSD-specific core file notes. */
15629 return process_netbsd_elf_note (pnote);
15630
b15fa79e
AM		 15631 else if (strneq (pnote->namedata, "SPU/", 4))
15632 {
15633 /* SPU-specific core file notes. */
15634 nt = pnote->namedata + 4;
15635 name = "SPU";
15636 }
15637
00e98fc7
TG		 15638 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15639 /* VMS/ia64-specific file notes. */
15640 nt = get_ia64_vms_note_type (pnote->type);
15641
70616151
TT		 15642 else if (const_strneq (pnote->namedata, "stapsdt"))
15643 nt = get_stapsdt_note_type (pnote->type);
15644
9437c45b 15645 else
1ec5cd37
NC		 15646 /* Don't recognize this note name; just use the default set of
15647 note type strings. */
00e98fc7 15648 nt = get_note_type (pnote->type);
9437c45b 15649
2aee03ae 15650 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15651
15652 if (const_strneq (pnote->namedata, "IPF/VMS"))
15653 return print_ia64_vms_note (pnote);
664f90a3
TT		 15654 else if (const_strneq (pnote->namedata, "GNU"))
15655 return print_gnu_note (pnote);
c6a9fc58
TT		 15656 else if (const_strneq (pnote->namedata, "stapsdt"))
15657 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15658 else if (const_strneq (pnote->namedata, "CORE"))
15659 return print_core_note (pnote);
00e98fc7
TG		 15660 else
15661 return 1;
779fe533
NC		 15662}
15663
6d118b09 15664
779fe533 15665static int
2cf0635d 15666process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15667{
2cf0635d
NC		 15668 Elf_External_Note * pnotes;
15669 Elf_External_Note * external;
c8071705 15670 char * end;
b34976b6 15671 int res = 1;
103f02d3 15672
779fe533
NC		 15673 if (length <= 0)
15674 return 0;
103f02d3 15675
3f5e193b 15676 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15677 _("notes"));
dd24e3da 15678 if (pnotes == NULL)
a6e9f9df 15679 return 0;
779fe533 15680
103f02d3 15681 external = pnotes;
103f02d3 15682
9dd3a467 15683 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15684 (unsigned long) offset, (unsigned long) length);
2aee03ae 15685 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15686
c8071705
NC		 15687 end = (char *) pnotes + length;
15688 while ((char *) external < end)
779fe533 15689 {
b34976b6 15690 Elf_Internal_Note inote;
15b42fb0
AM		 15691 size_t min_notesz;
15692 char *next;
2cf0635d 15693 char * temp = NULL;
c8071705 15694 size_t data_remaining = end - (char *) external;
6d118b09 15695
00e98fc7 15696 if (!is_ia64_vms ())
15b42fb0 15697 {
9dd3a467
NC		 15698 /* PR binutils/15191
15699 Make sure that there is enough data to read. */
15b42fb0
AM		 15700 min_notesz = offsetof (Elf_External_Note, name);
15701 if (data_remaining < min_notesz)
9dd3a467
NC		 15702 {
15703 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15704 (int) data_remaining);
15705 break;
15706 }
15b42fb0
AM		 15707 inote.type = BYTE_GET (external->type);
15708 inote.namesz = BYTE_GET (external->namesz);
15709 inote.namedata = external->name;
15710 inote.descsz = BYTE_GET (external->descsz);
15711 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15712 /* PR 17531: file: 3443835e. */
c8071705 15713 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15714 {
15715 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15716 inote.descdata = inote.namedata;
15717 inote.namesz = 0;
15718 }
14ae95f2 15719
15b42fb0
AM		 15720 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15721 next = inote.descdata + align_power (inote.descsz, 2);
15722 }
00e98fc7 15723 else
15b42fb0
AM		 15724 {
15725 Elf64_External_VMS_Note *vms_external;
00e98fc7 15726
9dd3a467
NC		 15727 /* PR binutils/15191
15728 Make sure that there is enough data to read. */
15b42fb0
AM		 15729 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15730 if (data_remaining < min_notesz)
9dd3a467
NC		 15731 {
15732 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15733 (int) data_remaining);
15734 break;
15735 }
3e55a963 15736
15b42fb0
AM		 15737 vms_external = (Elf64_External_VMS_Note *) external;
15738 inote.type = BYTE_GET (vms_external->type);
15739 inote.namesz = BYTE_GET (vms_external->namesz);
15740 inote.namedata = vms_external->name;
15741 inote.descsz = BYTE_GET (vms_external->descsz);
15742 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15743 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15744 next = inote.descdata + align_power (inote.descsz, 3);
15745 }
15746
15747 if (inote.descdata < (char *) external + min_notesz
15748 || next < (char *) external + min_notesz
5d921cbd
NC		 15749 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15750 || inote.namedata + inote.namesz < inote.namedata
15751 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15752 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15753 {
15b42fb0 15754 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15755 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15756 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15757 inote.type, inote.namesz, inote.descsz);
15758 break;
15759 }
15760
15b42fb0 15761 external = (Elf_External_Note *) next;
dd24e3da 15762
6d118b09
NC		 15763 /* Verify that name is null terminated. It appears that at least
15764 one version of Linux (RedHat 6.0) generates corefiles that don't
15765 comply with the ELF spec by failing to include the null byte in
15766 namesz. */
8b971f9f 15767 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15768 {
3f5e193b 15769 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15770 if (temp == NULL)
15771 {
8b73c356 15772 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15773 res = 0;
15774 break;
15775 }
76da6bbe 15776
6d118b09
NC		 15777 strncpy (temp, inote.namedata, inote.namesz);
15778 temp[inote.namesz] = 0;
76da6bbe 15779
6d118b09
NC		 15780 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15781 inote.namedata = temp;
15782 }
15783
15784 res &= process_note (& inote);
103f02d3 15785
6d118b09
NC		 15786 if (temp != NULL)
15787 {
15788 free (temp);
15789 temp = NULL;
15790 }
779fe533
NC		 15791 }
15792
15793 free (pnotes);
103f02d3 15794
779fe533
NC		 15795 return res;
15796}
15797
15798static int
2cf0635d 15799process_corefile_note_segments (FILE * file)
779fe533 15800{
2cf0635d 15801 Elf_Internal_Phdr * segment;
b34976b6
AM		 15802 unsigned int i;
15803 int res = 1;
103f02d3 15804
d93f0186 15805 if (! get_program_headers (file))
779fe533 15806 return 0;
103f02d3 15807
779fe533
NC		 15808 for (i = 0, segment = program_headers;
15809 i < elf_header.e_phnum;
b34976b6 15810 i++, segment++)
779fe533
NC		 15811 {
15812 if (segment->p_type == PT_NOTE)
103f02d3 15813 res &= process_corefile_note_segment (file,
30800947
NC		 15814 (bfd_vma) segment->p_offset,
15815 (bfd_vma) segment->p_filesz);
779fe533 15816 }
103f02d3 15817
779fe533
NC		 15818 return res;
15819}
15820
685080f2
NC		 15821static int
15822process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15823{
15824 Elf_External_Note * pnotes;
15825 Elf_External_Note * external;
c8071705 15826 char * end;
685080f2
NC		 15827 int res = 1;
15828
15829 if (length <= 0)
15830 return 0;
15831
15832 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15833 _("v850 notes"));
15834 if (pnotes == NULL)
15835 return 0;
15836
15837 external = pnotes;
c8071705 15838 end = (char*) pnotes + length;
685080f2
NC		 15839
15840 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15841 (unsigned long) offset, (unsigned long) length);
15842
c8071705 15843 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15844 {
15845 Elf_External_Note * next;
15846 Elf_Internal_Note inote;
15847
15848 inote.type = BYTE_GET (external->type);
15849 inote.namesz = BYTE_GET (external->namesz);
15850 inote.namedata = external->name;
15851 inote.descsz = BYTE_GET (external->descsz);
15852 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15853 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15854
c8071705
NC		 15855 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15856 {
15857 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15858 inote.descdata = inote.namedata;
15859 inote.namesz = 0;
15860 }
15861
685080f2
NC		 15862 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15863
c8071705 15864 if ( ((char *) next > end)
685080f2
NC		 15865 || ((char *) next < (char *) pnotes))
15866 {
15867 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15868 (unsigned long) ((char *) external - (char *) pnotes));
15869 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15870 inote.type, inote.namesz, inote.descsz);
15871 break;
15872 }
15873
15874 external = next;
15875
15876 /* Prevent out-of-bounds indexing. */
c8071705 15877 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15878 || inote.namedata + inote.namesz < inote.namedata)
15879 {
15880 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15881 (unsigned long) ((char *) external - (char *) pnotes));
15882 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15883 inote.type, inote.namesz, inote.descsz);
15884 break;
15885 }
15886
15887 printf (" %s: ", get_v850_elf_note_type (inote.type));
15888
15889 if (! print_v850_note (& inote))
15890 {
15891 res = 0;
15892 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15893 inote.namesz, inote.descsz);
15894 }
15895 }
15896
15897 free (pnotes);
15898
15899 return res;
15900}
15901
779fe533 15902static int
2cf0635d 15903process_note_sections (FILE * file)
1ec5cd37 15904{
2cf0635d 15905 Elf_Internal_Shdr * section;
1ec5cd37 15906 unsigned long i;
df565f32 15907 int n = 0;
1ec5cd37
NC		 15908 int res = 1;
15909
15910 for (i = 0, section = section_headers;
fa1908fd 15911 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15912 i++, section++)
685080f2
NC		 15913 {
15914 if (section->sh_type == SHT_NOTE)
15915 {
15916 res &= process_corefile_note_segment (file,
15917 (bfd_vma) section->sh_offset,
15918 (bfd_vma) section->sh_size);
15919 n++;
15920 }
15921
15922 if (( elf_header.e_machine == EM_V800
15923 || elf_header.e_machine == EM_V850
15924 || elf_header.e_machine == EM_CYGNUS_V850)
15925 && section->sh_type == SHT_RENESAS_INFO)
15926 {
15927 res &= process_v850_notes (file,
15928 (bfd_vma) section->sh_offset,
15929 (bfd_vma) section->sh_size);
15930 n++;
15931 }
15932 }
df565f32
NC		 15933
15934 if (n == 0)
15935 /* Try processing NOTE segments instead. */
15936 return process_corefile_note_segments (file);
1ec5cd37
NC		 15937
15938 return res;
15939}
15940
15941static int
2cf0635d 15942process_notes (FILE * file)
779fe533
NC		 15943{
15944 /* If we have not been asked to display the notes then do nothing. */
15945 if (! do_notes)
15946 return 1;
103f02d3 15947
779fe533 15948 if (elf_header.e_type != ET_CORE)
1ec5cd37 15949 return process_note_sections (file);
103f02d3 15950
779fe533 15951 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15952 if (elf_header.e_phnum > 0)
15953 return process_corefile_note_segments (file);
779fe533 15954
1ec5cd37
NC		 15955 printf (_("No note segments present in the core file.\n"));
15956 return 1;
779fe533
NC		 15957}
15958
252b5132 15959static int
2cf0635d 15960process_arch_specific (FILE * file)
252b5132 15961{
a952a375
NC		 15962 if (! do_arch)
15963 return 1;
15964
252b5132
RH		 15965 switch (elf_header.e_machine)
15966 {
11c1ff18
PB		 15967 case EM_ARM:
15968 return process_arm_specific (file);
252b5132 15969 case EM_MIPS:
4fe85591 15970 case EM_MIPS_RS3_LE:
252b5132
RH		 15971 return process_mips_specific (file);
15972 break;
35c08157
KLC		 15973 case EM_NDS32:
15974 return process_nds32_specific (file);
15975 break;
34c8bcba
JM		 15976 case EM_PPC:
15977 return process_power_specific (file);
15978 break;
643f7afb
AK		 15979 case EM_S390:
15980 case EM_S390_OLD:
15981 return process_s390_specific (file);
15982 break;
9e8c70f9
DM		 15983 case EM_SPARC:
15984 case EM_SPARC32PLUS:
15985 case EM_SPARCV9:
15986 return process_sparc_specific (file);
15987 break;
59e6276b
JM		 15988 case EM_TI_C6000:
15989 return process_tic6x_specific (file);
15990 break;
13761a11
NC		 15991 case EM_MSP430:
15992 return process_msp430x_specific (file);
252b5132
RH		 15993 default:
15994 break;
15995 }
15996 return 1;
15997}
15998
15999static int
2cf0635d 16000get_file_header (FILE * file)
252b5132 16001{
9ea033b2
NC		 16002 /* Read in the identity array. */
16003 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16004 return 0;
16005
9ea033b2 16006 /* Determine how to read the rest of the header. */
b34976b6 16007 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16008 {
16009 default: /* fall through */
16010 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16011 case ELFDATA2LSB:
16012 byte_get = byte_get_little_endian;
16013 byte_put = byte_put_little_endian;
16014 break;
16015 case ELFDATA2MSB:
16016 byte_get = byte_get_big_endian;
16017 byte_put = byte_put_big_endian;
16018 break;
9ea033b2
NC		 16019 }
16020
16021 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16022 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16023
16024 /* Read in the rest of the header. */
16025 if (is_32bit_elf)
16026 {
16027 Elf32_External_Ehdr ehdr32;
252b5132 16028
9ea033b2
NC		 16029 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16030 return 0;
103f02d3 16031
9ea033b2
NC		 16032 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16033 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16034 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16035 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16036 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16037 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16038 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16039 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16040 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16041 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16042 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16043 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16044 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16045 }
252b5132 16046 else
9ea033b2
NC		 16047 {
16048 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16049
16050 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16051 we will not be able to cope with the 64bit data found in
16052 64 ELF files. Detect this now and abort before we start
50c2245b 16053 overwriting things. */
a952a375
NC		 16054 if (sizeof (bfd_vma) < 8)
16055 {
e3c8793a
NC		 16056 error (_("This instance of readelf has been built without support for a\n\
1605764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16058 return 0;
16059 }
103f02d3 16060
9ea033b2
NC		 16061 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16062 return 0;
103f02d3 16063
9ea033b2
NC		 16064 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16065 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16066 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16067 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16068 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16069 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16070 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16071 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16072 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16073 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16074 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16075 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16076 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16077 }
252b5132 16078
7ece0d85
JJ		 16079 if (elf_header.e_shoff)
16080 {
16081 /* There may be some extensions in the first section header. Don't
16082 bomb if we can't read it. */
16083 if (is_32bit_elf)
049b0c3a 16084 get_32bit_section_headers (file, TRUE);
7ece0d85 16085 else
049b0c3a 16086 get_64bit_section_headers (file, TRUE);
7ece0d85 16087 }
560f3c1c 16088
252b5132
RH		 16089 return 1;
16090}
16091
fb52b2f4
NC		 16092/* Process one ELF object file according to the command line options.
16093 This file may actually be stored in an archive. The file is
16094 positioned at the start of the ELF object. */
16095
ff78d6d6 16096static int
2cf0635d 16097process_object (char * file_name, FILE * file)
252b5132 16098{
252b5132
RH		 16099 unsigned int i;
16100
252b5132
RH		 16101 if (! get_file_header (file))
16102 {
16103 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16104 return 1;
252b5132
RH		 16105 }
16106
16107 /* Initialise per file variables. */
60bca95a 16108 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16109 version_info[i] = 0;
16110
60bca95a 16111 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16112 dynamic_info[i] = 0;
5115b233 16113 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16114
16115 /* Process the file. */
16116 if (show_name)
16117 printf (_("\nFile: %s\n"), file_name);
16118
18bd398b
NC		 16119 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16120 Note we do this even if cmdline_dump_sects is empty because we
16121 must make sure that the dump_sets array is zeroed out before each
16122 object file is processed. */
16123 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16124 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16125
16126 if (num_cmdline_dump_sects > 0)
16127 {
16128 if (num_dump_sects == 0)
16129 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16130 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16131
16132 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16133 memcpy (dump_sects, cmdline_dump_sects,
16134 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16135 }
d70c5fc7 16136
252b5132 16137 if (! process_file_header ())
fb52b2f4 16138 return 1;
252b5132 16139
d1f5c6e3 16140 if (! process_section_headers (file))
2f62977e 16141 {
d1f5c6e3
L		 16142 /* Without loaded section headers we cannot process lots of
16143 things. */
2f62977e 16144 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16145
2f62977e 16146 if (! do_using_dynamic)
2c610e4b 16147 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16148 }
252b5132 16149
d1f5c6e3
L		 16150 if (! process_section_groups (file))
16151 {
16152 /* Without loaded section groups we cannot process unwind. */
16153 do_unwind = 0;
16154 }
16155
2f62977e 16156 if (process_program_headers (file))
b2d38a17 16157 process_dynamic_section (file);
252b5132
RH		 16158
16159 process_relocs (file);
16160
4d6ed7c8
NC		 16161 process_unwind (file);
16162
252b5132
RH		 16163 process_symbol_table (file);
16164
16165 process_syminfo (file);
16166
16167 process_version_sections (file);
16168
16169 process_section_contents (file);
f5842774 16170
1ec5cd37 16171 process_notes (file);
103f02d3 16172
047b2264
JJ		 16173 process_gnu_liblist (file);
16174
252b5132
RH		 16175 process_arch_specific (file);
16176
d93f0186
NC		 16177 if (program_headers)
16178 {
16179 free (program_headers);
16180 program_headers = NULL;
16181 }
16182
252b5132
RH		 16183 if (section_headers)
16184 {
16185 free (section_headers);
16186 section_headers = NULL;
16187 }
16188
16189 if (string_table)
16190 {
16191 free (string_table);
16192 string_table = NULL;
d40ac9bd 16193 string_table_length = 0;
252b5132
RH		 16194 }
16195
16196 if (dynamic_strings)
16197 {
16198 free (dynamic_strings);
16199 dynamic_strings = NULL;
d79b3d50 16200 dynamic_strings_length = 0;
252b5132
RH		 16201 }
16202
16203 if (dynamic_symbols)
16204 {
16205 free (dynamic_symbols);
16206 dynamic_symbols = NULL;
19936277 16207 num_dynamic_syms = 0;
252b5132
RH		 16208 }
16209
16210 if (dynamic_syminfo)
16211 {
16212 free (dynamic_syminfo);
16213 dynamic_syminfo = NULL;
16214 }
ff78d6d6 16215
293c573e
MR		 16216 if (dynamic_section)
16217 {
16218 free (dynamic_section);
16219 dynamic_section = NULL;
16220 }
16221
e4b17d5c
L		 16222 if (section_headers_groups)
16223 {
16224 free (section_headers_groups);
16225 section_headers_groups = NULL;
16226 }
16227
16228 if (section_groups)
16229 {
2cf0635d
NC		 16230 struct group_list * g;
16231 struct group_list * next;
e4b17d5c
L		 16232
16233 for (i = 0; i < group_count; i++)
16234 {
16235 for (g = section_groups [i].root; g != NULL; g = next)
16236 {
16237 next = g->next;
16238 free (g);
16239 }
16240 }
16241
16242 free (section_groups);
16243 section_groups = NULL;
16244 }
16245
19e6b90e 16246 free_debug_memory ();
18bd398b 16247
ff78d6d6 16248 return 0;
252b5132
RH		 16249}
16250
2cf0635d
NC		 16251/* Process an ELF archive.
16252 On entry the file is positioned just after the ARMAG string. */
16253
16254static int
16255process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16256{
16257 struct archive_info arch;
16258 struct archive_info nested_arch;
16259 size_t got;
2cf0635d
NC		 16260 int ret;
16261
16262 show_name = 1;
16263
16264 /* The ARCH structure is used to hold information about this archive. */
16265 arch.file_name = NULL;
16266 arch.file = NULL;
16267 arch.index_array = NULL;
16268 arch.sym_table = NULL;
16269 arch.longnames = NULL;
16270
16271 /* The NESTED_ARCH structure is used as a single-item cache of information
16272 about a nested archive (when members of a thin archive reside within
16273 another regular archive file). */
16274 nested_arch.file_name = NULL;
16275 nested_arch.file = NULL;
16276 nested_arch.index_array = NULL;
16277 nested_arch.sym_table = NULL;
16278 nested_arch.longnames = NULL;
16279
16280 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16281 {
16282 ret = 1;
16283 goto out;
4145f1d5 16284 }
fb52b2f4 16285
4145f1d5
NC		 16286 if (do_archive_index)
16287 {
2cf0635d 16288 if (arch.sym_table == NULL)
4145f1d5
NC		 16289 error (_("%s: unable to dump the index as none was found\n"), file_name);
16290 else
16291 {
591f7597 16292 unsigned long i, l;
4145f1d5
NC		 16293 unsigned long current_pos;
16294
591f7597
NC		 16295 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16296 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16297 current_pos = ftell (file);
16298
2cf0635d 16299 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16300 {
2cf0635d
NC		 16301 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16302 {
16303 char * member_name;
4145f1d5 16304
2cf0635d
NC		 16305 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16306
16307 if (member_name != NULL)
16308 {
16309 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16310
16311 if (qualified_name != NULL)
16312 {
c2a7d3f5
NC		 16313 printf (_("Contents of binary %s at offset "), qualified_name);
16314 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16315 putchar ('\n');
2cf0635d
NC		 16316 free (qualified_name);
16317 }
4145f1d5
NC		 16318 }
16319 }
2cf0635d
NC		 16320
16321 if (l >= arch.sym_size)
4145f1d5
NC		 16322 {
16323 error (_("%s: end of the symbol table reached before the end of the index\n"),
16324 file_name);
cb8f3167 16325 break;
4145f1d5 16326 }
591f7597
NC		 16327 /* PR 17531: file: 0b6630b2. */
16328 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16329 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16330 }
16331
c2a7d3f5
NC		 16332 if (arch.uses_64bit_indicies)
16333 l = (l + 7) & ~ 7;
16334 else
16335 l += l & 1;
16336
2cf0635d 16337 if (l < arch.sym_size)
c2a7d3f5
NC		 16338 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16339 file_name, arch.sym_size - l);
4145f1d5 16340
4145f1d5
NC		 16341 if (fseek (file, current_pos, SEEK_SET) != 0)
16342 {
16343 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16344 ret = 1;
16345 goto out;
4145f1d5 16346 }
fb52b2f4 16347 }
4145f1d5
NC		 16348
16349 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16350 && !do_segments && !do_header && !do_dump && !do_version
16351 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16352 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16353 {
16354 ret = 0; /* Archive index only. */
16355 goto out;
16356 }
fb52b2f4
NC		 16357 }
16358
d989285c 16359 ret = 0;
fb52b2f4
NC		 16360
16361 while (1)
16362 {
2cf0635d
NC		 16363 char * name;
16364 size_t namelen;
16365 char * qualified_name;
16366
16367 /* Read the next archive header. */
16368 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16369 {
16370 error (_("%s: failed to seek to next archive header\n"), file_name);
16371 return 1;
16372 }
16373 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16374 if (got != sizeof arch.arhdr)
16375 {
16376 if (got == 0)
16377 break;
16378 error (_("%s: failed to read archive header\n"), file_name);
16379 ret = 1;
16380 break;
16381 }
16382 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16383 {
16384 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16385 ret = 1;
16386 break;
16387 }
16388
16389 arch.next_arhdr_offset += sizeof arch.arhdr;
16390
16391 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16392 if (archive_file_size & 01)
16393 ++archive_file_size;
16394
16395 name = get_archive_member_name (&arch, &nested_arch);
16396 if (name == NULL)
fb52b2f4 16397 {
0fd3a477 16398 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16399 ret = 1;
16400 break;
fb52b2f4 16401 }
2cf0635d 16402 namelen = strlen (name);
fb52b2f4 16403
2cf0635d
NC		 16404 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16405 if (qualified_name == NULL)
fb52b2f4 16406 {
2cf0635d 16407 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16408 ret = 1;
16409 break;
fb52b2f4
NC		 16410 }
16411
2cf0635d
NC		 16412 if (is_thin_archive && arch.nested_member_origin == 0)
16413 {
16414 /* This is a proxy for an external member of a thin archive. */
16415 FILE * member_file;
16416 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16417 if (member_file_name == NULL)
16418 {
16419 ret = 1;
16420 break;
16421 }
16422
16423 member_file = fopen (member_file_name, "rb");
16424 if (member_file == NULL)
16425 {
16426 error (_("Input file '%s' is not readable.\n"), member_file_name);
16427 free (member_file_name);
16428 ret = 1;
16429 break;
16430 }
16431
16432 archive_file_offset = arch.nested_member_origin;
16433
16434 ret |= process_object (qualified_name, member_file);
16435
16436 fclose (member_file);
16437 free (member_file_name);
16438 }
16439 else if (is_thin_archive)
16440 {
a043396b
NC		 16441 /* PR 15140: Allow for corrupt thin archives. */
16442 if (nested_arch.file == NULL)
16443 {
16444 error (_("%s: contains corrupt thin archive: %s\n"),
16445 file_name, name);
16446 ret = 1;
16447 break;
16448 }
16449
2cf0635d
NC		 16450 /* This is a proxy for a member of a nested archive. */
16451 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16452
16453 /* The nested archive file will have been opened and setup by
16454 get_archive_member_name. */
16455 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16456 {
16457 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16458 ret = 1;
16459 break;
16460 }
16461
16462 ret |= process_object (qualified_name, nested_arch.file);
16463 }
16464 else
16465 {
16466 archive_file_offset = arch.next_arhdr_offset;
16467 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16468
2cf0635d
NC		 16469 ret |= process_object (qualified_name, file);
16470 }
fb52b2f4 16471
2b52916e
L		 16472 if (dump_sects != NULL)
16473 {
16474 free (dump_sects);
16475 dump_sects = NULL;
16476 num_dump_sects = 0;
16477 }
16478
2cf0635d 16479 free (qualified_name);
fb52b2f4
NC		 16480 }
16481
4145f1d5 16482 out:
2cf0635d
NC		 16483 if (nested_arch.file != NULL)
16484 fclose (nested_arch.file);
16485 release_archive (&nested_arch);
16486 release_archive (&arch);
fb52b2f4 16487
d989285c 16488 return ret;
fb52b2f4
NC		 16489}
16490
16491static int
2cf0635d 16492process_file (char * file_name)
fb52b2f4 16493{
2cf0635d 16494 FILE * file;
fb52b2f4
NC		 16495 struct stat statbuf;
16496 char armag[SARMAG];
16497 int ret;
16498
16499 if (stat (file_name, &statbuf) < 0)
16500 {
f24ddbdd
NC		 16501 if (errno == ENOENT)
16502 error (_("'%s': No such file\n"), file_name);
16503 else
16504 error (_("Could not locate '%s'. System error message: %s\n"),
16505 file_name, strerror (errno));
16506 return 1;
16507 }
16508
16509 if (! S_ISREG (statbuf.st_mode))
16510 {
16511 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16512 return 1;
16513 }
16514
16515 file = fopen (file_name, "rb");
16516 if (file == NULL)
16517 {
f24ddbdd 16518 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16519 return 1;
16520 }
16521
16522 if (fread (armag, SARMAG, 1, file) != 1)
16523 {
4145f1d5 16524 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16525 fclose (file);
16526 return 1;
16527 }
16528
f54498b4
NC		 16529 current_file_size = (bfd_size_type) statbuf.st_size;
16530
fb52b2f4 16531 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16532 ret = process_archive (file_name, file, FALSE);
16533 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16534 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16535 else
16536 {
4145f1d5
NC		 16537 if (do_archive_index)
16538 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16539 file_name);
16540
fb52b2f4
NC		 16541 rewind (file);
16542 archive_file_size = archive_file_offset = 0;
16543 ret = process_object (file_name, file);
16544 }
16545
16546 fclose (file);
16547
f54498b4 16548 current_file_size = 0;
fb52b2f4
NC		 16549 return ret;
16550}
16551
252b5132
RH		 16552#ifdef SUPPORT_DISASSEMBLY
16553/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16554 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16555 symbols. */
252b5132
RH		 16556
16557void
2cf0635d 16558print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16559{
16560 fprintf (outfile,"0x%8.8x", addr);
16561}
16562
e3c8793a 16563/* Needed by the i386 disassembler. */
252b5132
RH		 16564void
16565db_task_printsym (unsigned int addr)
16566{
16567 print_address (addr, stderr);
16568}
16569#endif
16570
16571int
2cf0635d 16572main (int argc, char ** argv)
252b5132 16573{
ff78d6d6
L		 16574 int err;
16575
252b5132
RH		 16576#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16577 setlocale (LC_MESSAGES, "");
3882b010
L		 16578#endif
16579#if defined (HAVE_SETLOCALE)
16580 setlocale (LC_CTYPE, "");
252b5132
RH		 16581#endif
16582 bindtextdomain (PACKAGE, LOCALEDIR);
16583 textdomain (PACKAGE);
16584
869b9d07
MM		 16585 expandargv (&argc, &argv);
16586
252b5132
RH		 16587 parse_args (argc, argv);
16588
18bd398b 16589 if (num_dump_sects > 0)
59f14fc0 16590 {
18bd398b 16591 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16592 cmdline_dump_sects = (dump_type *)
16593 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16594 if (cmdline_dump_sects == NULL)
591a748a 16595 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16596 else
16597 {
09c11c86
NC		 16598 memcpy (cmdline_dump_sects, dump_sects,
16599 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16600 num_cmdline_dump_sects = num_dump_sects;
16601 }
16602 }
16603
18bd398b
NC		 16604 if (optind < (argc - 1))
16605 show_name = 1;
5656ba2c
L		 16606 else if (optind >= argc)
16607 {
16608 warn (_("Nothing to do.\n"));
16609 usage (stderr);
16610 }
18bd398b 16611
ff78d6d6 16612 err = 0;
252b5132 16613 while (optind < argc)
18bd398b 16614 err |= process_file (argv[optind++]);
252b5132
RH		 16615
16616 if (dump_sects != NULL)
16617 free (dump_sects);
59f14fc0
AS		 16618 if (cmdline_dump_sects != NULL)
16619 free (cmdline_dump_sects);
252b5132 16620
ff78d6d6 16621 return err;
252b5132 16622}
A mirror of the official binutils-gdb repository