]> 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
Fix PR binutils/19147 -- off by one when printing NT_FILE note.
[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");
d4cb0ea0 3379 break;
55786da2
AK		 3380
3381 case EM_S390:
3382 if (e_flags & EF_S390_HIGH_GPRS)
3383 strcat (buf, ", highgprs");
d4cb0ea0 3384 break;
40b36596
JM		 3385
3386 case EM_TI_C6000:
3387 if ((e_flags & EF_C6000_REL))
3388 strcat (buf, ", relocatable module");
d4cb0ea0 3389 break;
13761a11
NC		 3390
3391 case EM_MSP430:
3392 strcat (buf, _(": architecture variant: "));
3393 switch (e_flags & EF_MSP430_MACH)
3394 {
3395 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3396 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3397 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3398 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3399 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3400 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3401 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3402 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3403 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3404 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3405 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3406 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3407 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3408 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3409 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3410 default:
3411 strcat (buf, _(": unknown")); break;
3412 }
3413
3414 if (e_flags & ~ EF_MSP430_MACH)
3415 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3416 }
3417 }
3418
3419 return buf;
3420}
3421
252b5132 3422static const char *
d3ba0551
AM		 3423get_osabi_name (unsigned int osabi)
3424{
3425 static char buff[32];
3426
3427 switch (osabi)
3428 {
3429 case ELFOSABI_NONE: return "UNIX - System V";
3430 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3431 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3432 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3433 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3434 case ELFOSABI_AIX: return "UNIX - AIX";
3435 case ELFOSABI_IRIX: return "UNIX - IRIX";
3436 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3437 case ELFOSABI_TRU64: return "UNIX - TRU64";
3438 case ELFOSABI_MODESTO: return "Novell - Modesto";
3439 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3440 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3441 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3442 case ELFOSABI_AROS: return "AROS";
11636f9e 3443 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3444 default:
40b36596
JM		 3445 if (osabi >= 64)
3446 switch (elf_header.e_machine)
3447 {
3448 case EM_ARM:
3449 switch (osabi)
3450 {
3451 case ELFOSABI_ARM: return "ARM";
3452 default:
3453 break;
3454 }
3455 break;
3456
3457 case EM_MSP430:
3458 case EM_MSP430_OLD:
619ed720 3459 case EM_VISIUM:
40b36596
JM		 3460 switch (osabi)
3461 {
3462 case ELFOSABI_STANDALONE: return _("Standalone App");
3463 default:
3464 break;
3465 }
3466 break;
3467
3468 case EM_TI_C6000:
3469 switch (osabi)
3470 {
3471 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3472 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3473 default:
3474 break;
3475 }
3476 break;
3477
3478 default:
3479 break;
3480 }
e9e44622 3481 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3482 return buff;
3483 }
3484}
3485
a06ea964
NC		 3486static const char *
3487get_aarch64_segment_type (unsigned long type)
3488{
3489 switch (type)
3490 {
3491 case PT_AARCH64_ARCHEXT:
3492 return "AARCH64_ARCHEXT";
3493 default:
3494 break;
3495 }
3496
3497 return NULL;
3498}
3499
b294bdf8
MM		 3500static const char *
3501get_arm_segment_type (unsigned long type)
3502{
3503 switch (type)
3504 {
3505 case PT_ARM_EXIDX:
3506 return "EXIDX";
3507 default:
3508 break;
3509 }
3510
3511 return NULL;
3512}
3513
d3ba0551
AM		 3514static const char *
3515get_mips_segment_type (unsigned long type)
252b5132
RH		 3516{
3517 switch (type)
3518 {
3519 case PT_MIPS_REGINFO:
3520 return "REGINFO";
3521 case PT_MIPS_RTPROC:
3522 return "RTPROC";
3523 case PT_MIPS_OPTIONS:
3524 return "OPTIONS";
351cdf24
MF		 3525 case PT_MIPS_ABIFLAGS:
3526 return "ABIFLAGS";
252b5132
RH		 3527 default:
3528 break;
3529 }
3530
3531 return NULL;
3532}
3533
103f02d3 3534static const char *
d3ba0551 3535get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3536{
3537 switch (type)
3538 {
3539 case PT_HP_TLS: return "HP_TLS";
3540 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3541 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3542 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3543 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3544 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3545 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3546 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3547 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3548 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3549 case PT_HP_PARALLEL: return "HP_PARALLEL";
3550 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3551 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3552 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3553 case PT_HP_STACK: return "HP_STACK";
3554 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3555 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3556 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3557 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3558 default:
3559 break;
3560 }
3561
3562 return NULL;
3563}
3564
4d6ed7c8 3565static const char *
d3ba0551 3566get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3567{
3568 switch (type)
3569 {
3570 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3571 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3572 case PT_HP_TLS: return "HP_TLS";
3573 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3574 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3575 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3576 default:
3577 break;
3578 }
3579
3580 return NULL;
3581}
3582
40b36596
JM		 3583static const char *
3584get_tic6x_segment_type (unsigned long type)
3585{
3586 switch (type)
3587 {
3588 case PT_C6000_PHATTR: return "C6000_PHATTR";
3589 default:
3590 break;
3591 }
3592
3593 return NULL;
3594}
3595
252b5132 3596static const char *
d3ba0551 3597get_segment_type (unsigned long p_type)
252b5132 3598{
b34976b6 3599 static char buff[32];
252b5132
RH		 3600
3601 switch (p_type)
3602 {
b34976b6
AM		 3603 case PT_NULL: return "NULL";
3604 case PT_LOAD: return "LOAD";
252b5132 3605 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3606 case PT_INTERP: return "INTERP";
3607 case PT_NOTE: return "NOTE";
3608 case PT_SHLIB: return "SHLIB";
3609 case PT_PHDR: return "PHDR";
13ae64f3 3610 case PT_TLS: return "TLS";
252b5132 3611
65765700
JJ		 3612 case PT_GNU_EH_FRAME:
3613 return "GNU_EH_FRAME";
2b05f1b7 3614 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3615 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3616
252b5132
RH		 3617 default:
3618 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3619 {
2cf0635d 3620 const char * result;
103f02d3 3621
252b5132
RH		 3622 switch (elf_header.e_machine)
3623 {
a06ea964
NC		 3624 case EM_AARCH64:
3625 result = get_aarch64_segment_type (p_type);
3626 break;
b294bdf8
MM		 3627 case EM_ARM:
3628 result = get_arm_segment_type (p_type);
3629 break;
252b5132 3630 case EM_MIPS:
4fe85591 3631 case EM_MIPS_RS3_LE:
252b5132
RH		 3632 result = get_mips_segment_type (p_type);
3633 break;
103f02d3
UD		 3634 case EM_PARISC:
3635 result = get_parisc_segment_type (p_type);
3636 break;
4d6ed7c8
NC		 3637 case EM_IA_64:
3638 result = get_ia64_segment_type (p_type);
3639 break;
40b36596
JM		 3640 case EM_TI_C6000:
3641 result = get_tic6x_segment_type (p_type);
3642 break;
252b5132
RH		 3643 default:
3644 result = NULL;
3645 break;
3646 }
103f02d3 3647
252b5132
RH		 3648 if (result != NULL)
3649 return result;
103f02d3 3650
252b5132
RH		 3651 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3652 }
3653 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3654 {
2cf0635d 3655 const char * result;
103f02d3
UD		 3656
3657 switch (elf_header.e_machine)
3658 {
3659 case EM_PARISC:
3660 result = get_parisc_segment_type (p_type);
3661 break;
00428cca
AM		 3662 case EM_IA_64:
3663 result = get_ia64_segment_type (p_type);
3664 break;
103f02d3
UD		 3665 default:
3666 result = NULL;
3667 break;
3668 }
3669
3670 if (result != NULL)
3671 return result;
3672
3673 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3674 }
252b5132 3675 else
e9e44622 3676 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3677
3678 return buff;
3679 }
3680}
3681
3682static const char *
d3ba0551 3683get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3684{
3685 switch (sh_type)
3686 {
b34976b6
AM		 3687 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3688 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3689 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3690 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3691 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3692 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3693 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3694 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3695 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3696 case SHT_MIPS_RELD: return "MIPS_RELD";
3697 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3698 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3699 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3700 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3701 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3702 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3703 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3704 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3705 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3706 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3707 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3708 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3709 case SHT_MIPS_LINE: return "MIPS_LINE";
3710 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3711 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3712 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3713 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3714 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3715 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3716 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3717 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3718 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3719 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3720 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3721 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3722 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3723 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3724 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3725 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3726 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3727 default:
3728 break;
3729 }
3730 return NULL;
3731}
3732
103f02d3 3733static const char *
d3ba0551 3734get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3735{
3736 switch (sh_type)
3737 {
3738 case SHT_PARISC_EXT: return "PARISC_EXT";
3739 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3740 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3741 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3742 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3743 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3744 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3745 default:
3746 break;
3747 }
3748 return NULL;
3749}
3750
4d6ed7c8 3751static const char *
d3ba0551 3752get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3753{
18bd398b 3754 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3755 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3756 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3757
4d6ed7c8
NC		 3758 switch (sh_type)
3759 {
148b93f2
NC		 3760 case SHT_IA_64_EXT: return "IA_64_EXT";
3761 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3762 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3763 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3764 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3765 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3766 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3767 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3768 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3769 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3770 default:
3771 break;
3772 }
3773 return NULL;
3774}
3775
d2b2c203
DJ		 3776static const char *
3777get_x86_64_section_type_name (unsigned int sh_type)
3778{
3779 switch (sh_type)
3780 {
3781 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3782 default:
3783 break;
3784 }
3785 return NULL;
3786}
3787
a06ea964
NC		 3788static const char *
3789get_aarch64_section_type_name (unsigned int sh_type)
3790{
3791 switch (sh_type)
3792 {
3793 case SHT_AARCH64_ATTRIBUTES:
3794 return "AARCH64_ATTRIBUTES";
3795 default:
3796 break;
3797 }
3798 return NULL;
3799}
3800
40a18ebd
NC		 3801static const char *
3802get_arm_section_type_name (unsigned int sh_type)
3803{
3804 switch (sh_type)
3805 {
7f6fed87
NC		 3806 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3807 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3808 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3809 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3810 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3811 default:
3812 break;
3813 }
3814 return NULL;
3815}
3816
40b36596
JM		 3817static const char *
3818get_tic6x_section_type_name (unsigned int sh_type)
3819{
3820 switch (sh_type)
3821 {
3822 case SHT_C6000_UNWIND:
3823 return "C6000_UNWIND";
3824 case SHT_C6000_PREEMPTMAP:
3825 return "C6000_PREEMPTMAP";
3826 case SHT_C6000_ATTRIBUTES:
3827 return "C6000_ATTRIBUTES";
3828 case SHT_TI_ICODE:
3829 return "TI_ICODE";
3830 case SHT_TI_XREF:
3831 return "TI_XREF";
3832 case SHT_TI_HANDLER:
3833 return "TI_HANDLER";
3834 case SHT_TI_INITINFO:
3835 return "TI_INITINFO";
3836 case SHT_TI_PHATTRS:
3837 return "TI_PHATTRS";
3838 default:
3839 break;
3840 }
3841 return NULL;
3842}
3843
13761a11
NC		 3844static const char *
3845get_msp430x_section_type_name (unsigned int sh_type)
3846{
3847 switch (sh_type)
3848 {
3849 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3850 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3851 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3852 default: return NULL;
3853 }
3854}
3855
685080f2
NC		 3856static const char *
3857get_v850_section_type_name (unsigned int sh_type)
3858{
3859 switch (sh_type)
3860 {
3861 case SHT_V850_SCOMMON: return "V850 Small Common";
3862 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3863 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3864 case SHT_RENESAS_IOP: return "RENESAS IOP";
3865 case SHT_RENESAS_INFO: return "RENESAS INFO";
3866 default: return NULL;
3867 }
3868}
3869
252b5132 3870static const char *
d3ba0551 3871get_section_type_name (unsigned int sh_type)
252b5132 3872{
b34976b6 3873 static char buff[32];
252b5132
RH		 3874
3875 switch (sh_type)
3876 {
3877 case SHT_NULL: return "NULL";
3878 case SHT_PROGBITS: return "PROGBITS";
3879 case SHT_SYMTAB: return "SYMTAB";
3880 case SHT_STRTAB: return "STRTAB";
3881 case SHT_RELA: return "RELA";
3882 case SHT_HASH: return "HASH";
3883 case SHT_DYNAMIC: return "DYNAMIC";
3884 case SHT_NOTE: return "NOTE";
3885 case SHT_NOBITS: return "NOBITS";
3886 case SHT_REL: return "REL";
3887 case SHT_SHLIB: return "SHLIB";
3888 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3889 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3890 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3891 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3892 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3893 case SHT_GROUP: return "GROUP";
3894 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3895 case SHT_GNU_verdef: return "VERDEF";
3896 case SHT_GNU_verneed: return "VERNEED";
3897 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3898 case 0x6ffffff0: return "VERSYM";
3899 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3900 case 0x7ffffffd: return "AUXILIARY";
3901 case 0x7fffffff: return "FILTER";
047b2264 3902 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3903
3904 default:
3905 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3906 {
2cf0635d 3907 const char * result;
252b5132
RH		 3908
3909 switch (elf_header.e_machine)
3910 {
3911 case EM_MIPS:
4fe85591 3912 case EM_MIPS_RS3_LE:
252b5132
RH		 3913 result = get_mips_section_type_name (sh_type);
3914 break;
103f02d3
UD		 3915 case EM_PARISC:
3916 result = get_parisc_section_type_name (sh_type);
3917 break;
4d6ed7c8
NC		 3918 case EM_IA_64:
3919 result = get_ia64_section_type_name (sh_type);
3920 break;
d2b2c203 3921 case EM_X86_64:
8a9036a4 3922 case EM_L1OM:
7a9068fe 3923 case EM_K1OM:
d2b2c203
DJ		 3924 result = get_x86_64_section_type_name (sh_type);
3925 break;
a06ea964
NC		 3926 case EM_AARCH64:
3927 result = get_aarch64_section_type_name (sh_type);
3928 break;
40a18ebd
NC		 3929 case EM_ARM:
3930 result = get_arm_section_type_name (sh_type);
3931 break;
40b36596
JM		 3932 case EM_TI_C6000:
3933 result = get_tic6x_section_type_name (sh_type);
3934 break;
13761a11
NC		 3935 case EM_MSP430:
3936 result = get_msp430x_section_type_name (sh_type);
3937 break;
685080f2
NC		 3938 case EM_V800:
3939 case EM_V850:
3940 case EM_CYGNUS_V850:
3941 result = get_v850_section_type_name (sh_type);
3942 break;
252b5132
RH		 3943 default:
3944 result = NULL;
3945 break;
3946 }
3947
3948 if (result != NULL)
3949 return result;
3950
c91d0dfb 3951 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
252b5132
RH		 3952 }
3953 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 3954 {
2cf0635d 3955 const char * result;
148b93f2
NC		 3956
3957 switch (elf_header.e_machine)
3958 {
3959 case EM_IA_64:
3960 result = get_ia64_section_type_name (sh_type);
3961 break;
3962 default:
3963 result = NULL;
3964 break;
3965 }
3966
3967 if (result != NULL)
3968 return result;
3969
3970 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3971 }
252b5132 3972 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 3973 {
3974 switch (elf_header.e_machine)
3975 {
3976 case EM_V800:
3977 case EM_V850:
3978 case EM_CYGNUS_V850:
3979 return get_v850_section_type_name (sh_type);
3980 default:
3981 break;
3982 }
3983
3984 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3985 }
252b5132 3986 else
a7dbfd1c
NC		 3987 /* This message is probably going to be displayed in a 15
3988 character wide field, so put the hex value first. */
3989 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 3990
252b5132
RH		 3991 return buff;
3992 }
3993}
3994
2979dc34 3995#define OPTION_DEBUG_DUMP 512
2c610e4b 3996#define OPTION_DYN_SYMS 513
fd2f0033
TT		 3997#define OPTION_DWARF_DEPTH 514
3998#define OPTION_DWARF_START 515
4723351a 3999#define OPTION_DWARF_CHECK 516
2979dc34 4000
85b1c36d 4001static struct option options[] =
252b5132 4002{
b34976b6 4003 {"all", no_argument, 0, 'a'},
252b5132
RH		 4004 {"file-header", no_argument, 0, 'h'},
4005 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4006 {"headers", no_argument, 0, 'e'},
4007 {"histogram", no_argument, 0, 'I'},
4008 {"segments", no_argument, 0, 'l'},
4009 {"sections", no_argument, 0, 'S'},
252b5132 4010 {"section-headers", no_argument, 0, 'S'},
f5842774 4011 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4012 {"section-details", no_argument, 0, 't'},
595cf52e 4013 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4014 {"symbols", no_argument, 0, 's'},
4015 {"syms", no_argument, 0, 's'},
2c610e4b 4016 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4017 {"relocs", no_argument, 0, 'r'},
4018 {"notes", no_argument, 0, 'n'},
4019 {"dynamic", no_argument, 0, 'd'},
a952a375 4020 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4021 {"version-info", no_argument, 0, 'V'},
4022 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4023 {"unwind", no_argument, 0, 'u'},
4145f1d5 4024 {"archive-index", no_argument, 0, 'c'},
b34976b6 4025 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4026 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4027 {"string-dump", required_argument, 0, 'p'},
0e602686 4028 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4029#ifdef SUPPORT_DISASSEMBLY
4030 {"instruction-dump", required_argument, 0, 'i'},
4031#endif
cf13d699 4032 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4033
fd2f0033
TT		 4034 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4035 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4036 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4037
b34976b6
AM		 4038 {"version", no_argument, 0, 'v'},
4039 {"wide", no_argument, 0, 'W'},
4040 {"help", no_argument, 0, 'H'},
4041 {0, no_argument, 0, 0}
252b5132
RH		 4042};
4043
4044static void
2cf0635d 4045usage (FILE * stream)
252b5132 4046{
92f01d61
JM		 4047 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4048 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4049 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4050 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4051 -h --file-header Display the ELF file header\n\
4052 -l --program-headers Display the program headers\n\
4053 --segments An alias for --program-headers\n\
4054 -S --section-headers Display the sections' header\n\
4055 --sections An alias for --section-headers\n\
f5842774 4056 -g --section-groups Display the section groups\n\
5477e8a0 4057 -t --section-details Display the section details\n\
8b53311e
NC		 4058 -e --headers Equivalent to: -h -l -S\n\
4059 -s --syms Display the symbol table\n\
3f08eb35 4060 --symbols An alias for --syms\n\
2c610e4b 4061 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4062 -n --notes Display the core notes (if present)\n\
4063 -r --relocs Display the relocations (if present)\n\
4064 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4065 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4066 -V --version-info Display the version sections (if present)\n\
1b31d05e 4067 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4068 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4069 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4070 -x --hex-dump=<number|name>\n\
4071 Dump the contents of section <number|name> as bytes\n\
4072 -p --string-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4074 -R --relocated-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4076 -z --decompress Decompress section before dumping it\n\
f9f0e732 4077 -w[lLiaprmfFsoRt] or\n\
1ed06042 4078 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4079 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4080 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4081 =addr,=cu_index]\n\
8b53311e 4082 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4083 fprintf (stream, _("\
4084 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4085 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4086 or deeper\n"));
252b5132 4087#ifdef SUPPORT_DISASSEMBLY
92f01d61 4088 fprintf (stream, _("\
09c11c86
NC		 4089 -i --instruction-dump=<number|name>\n\
4090 Disassemble the contents of section <number|name>\n"));
252b5132 4091#endif
92f01d61 4092 fprintf (stream, _("\
8b53311e
NC		 4093 -I --histogram Display histogram of bucket list lengths\n\
4094 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4095 @<file> Read options from <file>\n\
8b53311e
NC		 4096 -H --help Display this information\n\
4097 -v --version Display the version number of readelf\n"));
1118d252 4098
92f01d61
JM		 4099 if (REPORT_BUGS_TO[0] && stream == stdout)
4100 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4101
92f01d61 4102 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4103}
4104
18bd398b
NC		 4105/* Record the fact that the user wants the contents of section number
4106 SECTION to be displayed using the method(s) encoded as flags bits
4107 in TYPE. Note, TYPE can be zero if we are creating the array for
4108 the first time. */
4109
252b5132 4110static void
09c11c86 4111request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4112{
4113 if (section >= num_dump_sects)
4114 {
2cf0635d 4115 dump_type * new_dump_sects;
252b5132 4116
3f5e193b
NC		 4117 new_dump_sects = (dump_type *) calloc (section + 1,
4118 sizeof (* dump_sects));
252b5132
RH		 4119
4120 if (new_dump_sects == NULL)
591a748a 4121 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4122 else
4123 {
4124 /* Copy current flag settings. */
09c11c86 4125 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4126
4127 free (dump_sects);
4128
4129 dump_sects = new_dump_sects;
4130 num_dump_sects = section + 1;
4131 }
4132 }
4133
4134 if (dump_sects)
b34976b6 4135 dump_sects[section] |= type;
252b5132
RH		 4136
4137 return;
4138}
4139
aef1f6d0
DJ		 4140/* Request a dump by section name. */
4141
4142static void
2cf0635d 4143request_dump_byname (const char * section, dump_type type)
aef1f6d0 4144{
2cf0635d 4145 struct dump_list_entry * new_request;
aef1f6d0 4146
3f5e193b
NC		 4147 new_request = (struct dump_list_entry *)
4148 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4149 if (!new_request)
591a748a 4150 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4151
4152 new_request->name = strdup (section);
4153 if (!new_request->name)
591a748a 4154 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4155
4156 new_request->type = type;
4157
4158 new_request->next = dump_sects_byname;
4159 dump_sects_byname = new_request;
4160}
4161
cf13d699
NC		 4162static inline void
4163request_dump (dump_type type)
4164{
4165 int section;
4166 char * cp;
4167
4168 do_dump++;
4169 section = strtoul (optarg, & cp, 0);
4170
4171 if (! *cp && section >= 0)
4172 request_dump_bynumber (section, type);
4173 else
4174 request_dump_byname (optarg, type);
4175}
4176
4177
252b5132 4178static void
2cf0635d 4179parse_args (int argc, char ** argv)
252b5132
RH		 4180{
4181 int c;
4182
4183 if (argc < 2)
92f01d61 4184 usage (stderr);
252b5132
RH		 4185
4186 while ((c = getopt_long
0e602686 4187 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4188 {
252b5132
RH		 4189 switch (c)
4190 {
4191 case 0:
4192 /* Long options. */
4193 break;
4194 case 'H':
92f01d61 4195 usage (stdout);
252b5132
RH		 4196 break;
4197
4198 case 'a':
b34976b6
AM		 4199 do_syms++;
4200 do_reloc++;
4201 do_unwind++;
4202 do_dynamic++;
4203 do_header++;
4204 do_sections++;
f5842774 4205 do_section_groups++;
b34976b6
AM		 4206 do_segments++;
4207 do_version++;
4208 do_histogram++;
4209 do_arch++;
4210 do_notes++;
252b5132 4211 break;
f5842774
L		 4212 case 'g':
4213 do_section_groups++;
4214 break;
5477e8a0 4215 case 't':
595cf52e 4216 case 'N':
5477e8a0
L		 4217 do_sections++;
4218 do_section_details++;
595cf52e 4219 break;
252b5132 4220 case 'e':
b34976b6
AM		 4221 do_header++;
4222 do_sections++;
4223 do_segments++;
252b5132 4224 break;
a952a375 4225 case 'A':
b34976b6 4226 do_arch++;
a952a375 4227 break;
252b5132 4228 case 'D':
b34976b6 4229 do_using_dynamic++;
252b5132
RH		 4230 break;
4231 case 'r':
b34976b6 4232 do_reloc++;
252b5132 4233 break;
4d6ed7c8 4234 case 'u':
b34976b6 4235 do_unwind++;
4d6ed7c8 4236 break;
252b5132 4237 case 'h':
b34976b6 4238 do_header++;
252b5132
RH		 4239 break;
4240 case 'l':
b34976b6 4241 do_segments++;
252b5132
RH		 4242 break;
4243 case 's':
b34976b6 4244 do_syms++;
252b5132
RH		 4245 break;
4246 case 'S':
b34976b6 4247 do_sections++;
252b5132
RH		 4248 break;
4249 case 'd':
b34976b6 4250 do_dynamic++;
252b5132 4251 break;
a952a375 4252 case 'I':
b34976b6 4253 do_histogram++;
a952a375 4254 break;
779fe533 4255 case 'n':
b34976b6 4256 do_notes++;
779fe533 4257 break;
4145f1d5
NC		 4258 case 'c':
4259 do_archive_index++;
4260 break;
252b5132 4261 case 'x':
cf13d699 4262 request_dump (HEX_DUMP);
aef1f6d0 4263 break;
09c11c86 4264 case 'p':
cf13d699
NC		 4265 request_dump (STRING_DUMP);
4266 break;
4267 case 'R':
4268 request_dump (RELOC_DUMP);
09c11c86 4269 break;
0e602686
NC		 4270 case 'z':
4271 decompress_dumps++;
4272 break;
252b5132 4273 case 'w':
b34976b6 4274 do_dump++;
252b5132 4275 if (optarg == 0)
613ff48b
CC		 4276 {
4277 do_debugging = 1;
4278 dwarf_select_sections_all ();
4279 }
252b5132
RH		 4280 else
4281 {
4282 do_debugging = 0;
4cb93e3b 4283 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4284 }
4285 break;
2979dc34 4286 case OPTION_DEBUG_DUMP:
b34976b6 4287 do_dump++;
2979dc34
JJ		 4288 if (optarg == 0)
4289 do_debugging = 1;
4290 else
4291 {
2979dc34 4292 do_debugging = 0;
4cb93e3b 4293 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4294 }
4295 break;
fd2f0033
TT		 4296 case OPTION_DWARF_DEPTH:
4297 {
4298 char *cp;
4299
4300 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4301 }
4302 break;
4303 case OPTION_DWARF_START:
4304 {
4305 char *cp;
4306
4307 dwarf_start_die = strtoul (optarg, & cp, 0);
4308 }
4309 break;
4723351a
CC		 4310 case OPTION_DWARF_CHECK:
4311 dwarf_check = 1;
4312 break;
2c610e4b
L		 4313 case OPTION_DYN_SYMS:
4314 do_dyn_syms++;
4315 break;
252b5132
RH		 4316#ifdef SUPPORT_DISASSEMBLY
4317 case 'i':
cf13d699
NC		 4318 request_dump (DISASS_DUMP);
4319 break;
252b5132
RH		 4320#endif
4321 case 'v':
4322 print_version (program_name);
4323 break;
4324 case 'V':
b34976b6 4325 do_version++;
252b5132 4326 break;
d974e256 4327 case 'W':
b34976b6 4328 do_wide++;
d974e256 4329 break;
252b5132 4330 default:
252b5132
RH		 4331 /* xgettext:c-format */
4332 error (_("Invalid option '-%c'\n"), c);
4333 /* Drop through. */
4334 case '?':
92f01d61 4335 usage (stderr);
252b5132
RH		 4336 }
4337 }
4338
4d6ed7c8 4339 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4340 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4341 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4342 && !do_section_groups && !do_archive_index
4343 && !do_dyn_syms)
92f01d61 4344 usage (stderr);
252b5132
RH		 4345}
4346
4347static const char *
d3ba0551 4348get_elf_class (unsigned int elf_class)
252b5132 4349{
b34976b6 4350 static char buff[32];
103f02d3 4351
252b5132
RH		 4352 switch (elf_class)
4353 {
4354 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4355 case ELFCLASS32: return "ELF32";
4356 case ELFCLASS64: return "ELF64";
ab5e7794 4357 default:
e9e44622 4358 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4359 return buff;
252b5132
RH		 4360 }
4361}
4362
4363static const char *
d3ba0551 4364get_data_encoding (unsigned int encoding)
252b5132 4365{
b34976b6 4366 static char buff[32];
103f02d3 4367
252b5132
RH		 4368 switch (encoding)
4369 {
4370 case ELFDATANONE: return _("none");
33c63f9d
CM		 4371 case ELFDATA2LSB: return _("2's complement, little endian");
4372 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4373 default:
e9e44622 4374 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4375 return buff;
252b5132
RH		 4376 }
4377}
4378
252b5132 4379/* Decode the data held in 'elf_header'. */
ee42cf8c 4380
252b5132 4381static int
d3ba0551 4382process_file_header (void)
252b5132 4383{
b34976b6
AM		 4384 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4385 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4386 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4387 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4388 {
4389 error
4390 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4391 return 0;
4392 }
4393
2dc4cec1
L		 4394 init_dwarf_regnames (elf_header.e_machine);
4395
252b5132
RH		 4396 if (do_header)
4397 {
4398 int i;
4399
4400 printf (_("ELF Header:\n"));
4401 printf (_(" Magic: "));
b34976b6
AM		 4402 for (i = 0; i < EI_NIDENT; i++)
4403 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4404 printf ("\n");
4405 printf (_(" Class: %s\n"),
b34976b6 4406 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4407 printf (_(" Data: %s\n"),
b34976b6 4408 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4409 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4410 elf_header.e_ident[EI_VERSION],
4411 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4412 ? "(current)"
b34976b6 4413 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4414 ? _("<unknown: %lx>")
789be9f7 4415 : "")));
252b5132 4416 printf (_(" OS/ABI: %s\n"),
b34976b6 4417 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4418 printf (_(" ABI Version: %d\n"),
b34976b6 4419 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4420 printf (_(" Type: %s\n"),
4421 get_file_type (elf_header.e_type));
4422 printf (_(" Machine: %s\n"),
4423 get_machine_name (elf_header.e_machine));
4424 printf (_(" Version: 0x%lx\n"),
4425 (unsigned long) elf_header.e_version);
76da6bbe 4426
f7a99963
NC		 4427 printf (_(" Entry point address: "));
4428 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4429 printf (_("\n Start of program headers: "));
4430 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4431 printf (_(" (bytes into file)\n Start of section headers: "));
4432 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4433 printf (_(" (bytes into file)\n"));
76da6bbe 4434
252b5132
RH		 4435 printf (_(" Flags: 0x%lx%s\n"),
4436 (unsigned long) elf_header.e_flags,
4437 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4438 printf (_(" Size of this header: %ld (bytes)\n"),
4439 (long) elf_header.e_ehsize);
4440 printf (_(" Size of program headers: %ld (bytes)\n"),
4441 (long) elf_header.e_phentsize);
2046a35d 4442 printf (_(" Number of program headers: %ld"),
252b5132 4443 (long) elf_header.e_phnum);
2046a35d
AM		 4444 if (section_headers != NULL
4445 && elf_header.e_phnum == PN_XNUM
4446 && section_headers[0].sh_info != 0)
cc5914eb 4447 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4448 putc ('\n', stdout);
252b5132
RH		 4449 printf (_(" Size of section headers: %ld (bytes)\n"),
4450 (long) elf_header.e_shentsize);
560f3c1c 4451 printf (_(" Number of section headers: %ld"),
252b5132 4452 (long) elf_header.e_shnum);
4fbb74a6 4453 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4454 printf (" (%ld)", (long) section_headers[0].sh_size);
4455 putc ('\n', stdout);
4456 printf (_(" Section header string table index: %ld"),
252b5132 4457 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4458 if (section_headers != NULL
4459 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4460 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4461 else if (elf_header.e_shstrndx != SHN_UNDEF
4462 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4463 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4464 putc ('\n', stdout);
4465 }
4466
4467 if (section_headers != NULL)
4468 {
2046a35d
AM		 4469 if (elf_header.e_phnum == PN_XNUM
4470 && section_headers[0].sh_info != 0)
4471 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4472 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4473 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4474 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4475 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4476 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4477 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4478 free (section_headers);
4479 section_headers = NULL;
252b5132 4480 }
103f02d3 4481
9ea033b2
NC		 4482 return 1;
4483}
4484
e0a31db1 4485static bfd_boolean
91d6fa6a 4486get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4487{
2cf0635d
NC		 4488 Elf32_External_Phdr * phdrs;
4489 Elf32_External_Phdr * external;
4490 Elf_Internal_Phdr * internal;
b34976b6 4491 unsigned int i;
e0a31db1
NC		 4492 unsigned int size = elf_header.e_phentsize;
4493 unsigned int num = elf_header.e_phnum;
4494
4495 /* PR binutils/17531: Cope with unexpected section header sizes. */
4496 if (size == 0 || num == 0)
4497 return FALSE;
4498 if (size < sizeof * phdrs)
4499 {
4500 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4501 return FALSE;
4502 }
4503 if (size > sizeof * phdrs)
4504 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4505
3f5e193b 4506 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4507 size, num, _("program headers"));
4508 if (phdrs == NULL)
4509 return FALSE;
9ea033b2 4510
91d6fa6a 4511 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4512 i < elf_header.e_phnum;
b34976b6 4513 i++, internal++, external++)
252b5132 4514 {
9ea033b2
NC		 4515 internal->p_type = BYTE_GET (external->p_type);
4516 internal->p_offset = BYTE_GET (external->p_offset);
4517 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4518 internal->p_paddr = BYTE_GET (external->p_paddr);
4519 internal->p_filesz = BYTE_GET (external->p_filesz);
4520 internal->p_memsz = BYTE_GET (external->p_memsz);
4521 internal->p_flags = BYTE_GET (external->p_flags);
4522 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4523 }
4524
9ea033b2 4525 free (phdrs);
e0a31db1 4526 return TRUE;
252b5132
RH		 4527}
4528
e0a31db1 4529static bfd_boolean
91d6fa6a 4530get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4531{
2cf0635d
NC		 4532 Elf64_External_Phdr * phdrs;
4533 Elf64_External_Phdr * external;
4534 Elf_Internal_Phdr * internal;
b34976b6 4535 unsigned int i;
e0a31db1
NC		 4536 unsigned int size = elf_header.e_phentsize;
4537 unsigned int num = elf_header.e_phnum;
4538
4539 /* PR binutils/17531: Cope with unexpected section header sizes. */
4540 if (size == 0 || num == 0)
4541 return FALSE;
4542 if (size < sizeof * phdrs)
4543 {
4544 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4545 return FALSE;
4546 }
4547 if (size > sizeof * phdrs)
4548 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4549
3f5e193b 4550 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4551 size, num, _("program headers"));
a6e9f9df 4552 if (!phdrs)
e0a31db1 4553 return FALSE;
9ea033b2 4554
91d6fa6a 4555 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4556 i < elf_header.e_phnum;
b34976b6 4557 i++, internal++, external++)
9ea033b2
NC		 4558 {
4559 internal->p_type = BYTE_GET (external->p_type);
4560 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4561 internal->p_offset = BYTE_GET (external->p_offset);
4562 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4563 internal->p_paddr = BYTE_GET (external->p_paddr);
4564 internal->p_filesz = BYTE_GET (external->p_filesz);
4565 internal->p_memsz = BYTE_GET (external->p_memsz);
4566 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4567 }
4568
4569 free (phdrs);
e0a31db1 4570 return TRUE;
9ea033b2 4571}
252b5132 4572
d93f0186
NC		 4573/* Returns 1 if the program headers were read into `program_headers'. */
4574
4575static int
2cf0635d 4576get_program_headers (FILE * file)
d93f0186 4577{
2cf0635d 4578 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4579
4580 /* Check cache of prior read. */
4581 if (program_headers != NULL)
4582 return 1;
4583
3f5e193b
NC		 4584 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4585 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4586
4587 if (phdrs == NULL)
4588 {
8b73c356
NC		 4589 error (_("Out of memory reading %u program headers\n"),
4590 elf_header.e_phnum);
d93f0186
NC		 4591 return 0;
4592 }
4593
4594 if (is_32bit_elf
4595 ? get_32bit_program_headers (file, phdrs)
4596 : get_64bit_program_headers (file, phdrs))
4597 {
4598 program_headers = phdrs;
4599 return 1;
4600 }
4601
4602 free (phdrs);
4603 return 0;
4604}
4605
2f62977e
NC		 4606/* Returns 1 if the program headers were loaded. */
4607
252b5132 4608static int
2cf0635d 4609process_program_headers (FILE * file)
252b5132 4610{
2cf0635d 4611 Elf_Internal_Phdr * segment;
b34976b6 4612 unsigned int i;
252b5132
RH		 4613
4614 if (elf_header.e_phnum == 0)
4615 {
82f2dbf7
NC		 4616 /* PR binutils/12467. */
4617 if (elf_header.e_phoff != 0)
4618 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4619 " header offset, but no program headers\n"));
82f2dbf7 4620 else if (do_segments)
252b5132 4621 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4622 return 0;
252b5132
RH		 4623 }
4624
4625 if (do_segments && !do_header)
4626 {
f7a99963
NC		 4627 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4628 printf (_("Entry point "));
4629 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4630 printf (_("\nThere are %d program headers, starting at offset "),
4631 elf_header.e_phnum);
4632 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4633 printf ("\n");
252b5132
RH		 4634 }
4635
d93f0186 4636 if (! get_program_headers (file))
252b5132 4637 return 0;
103f02d3 4638
252b5132
RH		 4639 if (do_segments)
4640 {
3a1a2036
NC		 4641 if (elf_header.e_phnum > 1)
4642 printf (_("\nProgram Headers:\n"));
4643 else
4644 printf (_("\nProgram Headers:\n"));
76da6bbe 4645
f7a99963
NC		 4646 if (is_32bit_elf)
4647 printf
4648 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4649 else if (do_wide)
4650 printf
4651 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4652 else
4653 {
4654 printf
4655 (_(" Type Offset VirtAddr PhysAddr\n"));
4656 printf
4657 (_(" FileSiz MemSiz Flags Align\n"));
4658 }
252b5132
RH		 4659 }
4660
252b5132 4661 dynamic_addr = 0;
1b228002 4662 dynamic_size = 0;
252b5132
RH		 4663
4664 for (i = 0, segment = program_headers;
4665 i < elf_header.e_phnum;
b34976b6 4666 i++, segment++)
252b5132
RH		 4667 {
4668 if (do_segments)
4669 {
103f02d3 4670 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4671
4672 if (is_32bit_elf)
4673 {
4674 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4675 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4676 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4677 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4678 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4679 printf ("%c%c%c ",
4680 (segment->p_flags & PF_R ? 'R' : ' '),
4681 (segment->p_flags & PF_W ? 'W' : ' '),
4682 (segment->p_flags & PF_X ? 'E' : ' '));
4683 printf ("%#lx", (unsigned long) segment->p_align);
4684 }
d974e256
JJ		 4685 else if (do_wide)
4686 {
4687 if ((unsigned long) segment->p_offset == segment->p_offset)
4688 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4689 else
4690 {
4691 print_vma (segment->p_offset, FULL_HEX);
4692 putchar (' ');
4693 }
4694
4695 print_vma (segment->p_vaddr, FULL_HEX);
4696 putchar (' ');
4697 print_vma (segment->p_paddr, FULL_HEX);
4698 putchar (' ');
4699
4700 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4701 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4702 else
4703 {
4704 print_vma (segment->p_filesz, FULL_HEX);
4705 putchar (' ');
4706 }
4707
4708 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4709 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4710 else
4711 {
f48e6c45 4712 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4713 }
4714
4715 printf (" %c%c%c ",
4716 (segment->p_flags & PF_R ? 'R' : ' '),
4717 (segment->p_flags & PF_W ? 'W' : ' '),
4718 (segment->p_flags & PF_X ? 'E' : ' '));
4719
4720 if ((unsigned long) segment->p_align == segment->p_align)
4721 printf ("%#lx", (unsigned long) segment->p_align);
4722 else
4723 {
4724 print_vma (segment->p_align, PREFIX_HEX);
4725 }
4726 }
f7a99963
NC		 4727 else
4728 {
4729 print_vma (segment->p_offset, FULL_HEX);
4730 putchar (' ');
4731 print_vma (segment->p_vaddr, FULL_HEX);
4732 putchar (' ');
4733 print_vma (segment->p_paddr, FULL_HEX);
4734 printf ("\n ");
4735 print_vma (segment->p_filesz, FULL_HEX);
4736 putchar (' ');
4737 print_vma (segment->p_memsz, FULL_HEX);
4738 printf (" %c%c%c ",
4739 (segment->p_flags & PF_R ? 'R' : ' '),
4740 (segment->p_flags & PF_W ? 'W' : ' '),
4741 (segment->p_flags & PF_X ? 'E' : ' '));
4742 print_vma (segment->p_align, HEX);
4743 }
252b5132
RH		 4744 }
4745
f54498b4
NC		 4746 if (do_segments)
4747 putc ('\n', stdout);
4748
252b5132
RH		 4749 switch (segment->p_type)
4750 {
252b5132
RH		 4751 case PT_DYNAMIC:
4752 if (dynamic_addr)
4753 error (_("more than one dynamic segment\n"));
4754
20737c13
AM		 4755 /* By default, assume that the .dynamic section is the first
4756 section in the DYNAMIC segment. */
4757 dynamic_addr = segment->p_offset;
4758 dynamic_size = segment->p_filesz;
f54498b4
NC		 4759 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4760 if (dynamic_addr + dynamic_size >= current_file_size)
4761 {
4762 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4763 dynamic_addr = dynamic_size = 0;
4764 }
20737c13 4765
b2d38a17
NC		 4766 /* Try to locate the .dynamic section. If there is
4767 a section header table, we can easily locate it. */
4768 if (section_headers != NULL)
4769 {
2cf0635d 4770 Elf_Internal_Shdr * sec;
b2d38a17 4771
89fac5e3
RS		 4772 sec = find_section (".dynamic");
4773 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4774 {
28f997cf
TG		 4775 /* A corresponding .dynamic section is expected, but on
4776 IA-64/OpenVMS it is OK for it to be missing. */
4777 if (!is_ia64_vms ())
4778 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4779 break;
4780 }
4781
42bb2e33 4782 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4783 {
4784 dynamic_size = 0;
4785 break;
4786 }
42bb2e33 4787
b2d38a17
NC		 4788 dynamic_addr = sec->sh_offset;
4789 dynamic_size = sec->sh_size;
4790
4791 if (dynamic_addr < segment->p_offset
4792 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4793 warn (_("the .dynamic section is not contained"
4794 " within the dynamic segment\n"));
b2d38a17 4795 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4796 warn (_("the .dynamic section is not the first section"
4797 " in the dynamic segment.\n"));
b2d38a17 4798 }
252b5132
RH		 4799 break;
4800
4801 case PT_INTERP:
fb52b2f4
NC		 4802 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4803 SEEK_SET))
252b5132
RH		 4804 error (_("Unable to find program interpreter name\n"));
4805 else
4806 {
f8eae8b2 4807 char fmt [32];
9495b2e6 4808 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4809
4810 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4811 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4812
252b5132 4813 program_interpreter[0] = 0;
7bd7b3ef
AM		 4814 if (fscanf (file, fmt, program_interpreter) <= 0)
4815 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4816
4817 if (do_segments)
f54498b4 4818 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4819 program_interpreter);
4820 }
4821 break;
4822 }
252b5132
RH		 4823 }
4824
c256ffe7 4825 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4826 {
4827 printf (_("\n Section to Segment mapping:\n"));
4828 printf (_(" Segment Sections...\n"));
4829
252b5132
RH		 4830 for (i = 0; i < elf_header.e_phnum; i++)
4831 {
9ad5cbcf 4832 unsigned int j;
2cf0635d 4833 Elf_Internal_Shdr * section;
252b5132
RH		 4834
4835 segment = program_headers + i;
b391a3e3 4836 section = section_headers + 1;
252b5132
RH		 4837
4838 printf (" %2.2d ", i);
4839
b34976b6 4840 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4841 {
f4638467
AM		 4842 if (!ELF_TBSS_SPECIAL (section, segment)
4843 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4844 printf ("%s ", printable_section_name (section));
252b5132
RH		 4845 }
4846
4847 putc ('\n',stdout);
4848 }
4849 }
4850
252b5132
RH		 4851 return 1;
4852}
4853
4854
d93f0186
NC		 4855/* Find the file offset corresponding to VMA by using the program headers. */
4856
4857static long
2cf0635d 4858offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4859{
2cf0635d 4860 Elf_Internal_Phdr * seg;
d93f0186
NC		 4861
4862 if (! get_program_headers (file))
4863 {
4864 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4865 return (long) vma;
4866 }
4867
4868 for (seg = program_headers;
4869 seg < program_headers + elf_header.e_phnum;
4870 ++seg)
4871 {
4872 if (seg->p_type != PT_LOAD)
4873 continue;
4874
4875 if (vma >= (seg->p_vaddr & -seg->p_align)
4876 && vma + size <= seg->p_vaddr + seg->p_filesz)
4877 return vma - seg->p_vaddr + seg->p_offset;
4878 }
4879
4880 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4881 (unsigned long) vma);
d93f0186
NC		 4882 return (long) vma;
4883}
4884
4885
049b0c3a
NC		 4886/* Allocate memory and load the sections headers into the global pointer
4887 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4888 generate any error messages if the load fails. */
4889
4890static bfd_boolean
4891get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4892{
2cf0635d
NC		 4893 Elf32_External_Shdr * shdrs;
4894 Elf_Internal_Shdr * internal;
b34976b6 4895 unsigned int i;
049b0c3a
NC		 4896 unsigned int size = elf_header.e_shentsize;
4897 unsigned int num = probe ? 1 : elf_header.e_shnum;
4898
4899 /* PR binutils/17531: Cope with unexpected section header sizes. */
4900 if (size == 0 || num == 0)
4901 return FALSE;
4902 if (size < sizeof * shdrs)
4903 {
4904 if (! probe)
4905 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4906 return FALSE;
4907 }
4908 if (!probe && size > sizeof * shdrs)
4909 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 4910
3f5e193b 4911 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4912 size, num,
4913 probe ? NULL : _("section headers"));
4914 if (shdrs == NULL)
4915 return FALSE;
252b5132 4916
049b0c3a
NC		 4917 if (section_headers != NULL)
4918 free (section_headers);
3f5e193b
NC		 4919 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4920 sizeof (Elf_Internal_Shdr));
252b5132
RH		 4921 if (section_headers == NULL)
4922 {
049b0c3a 4923 if (!probe)
8b73c356 4924 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4925 return FALSE;
252b5132
RH		 4926 }
4927
4928 for (i = 0, internal = section_headers;
560f3c1c 4929 i < num;
b34976b6 4930 i++, internal++)
252b5132
RH		 4931 {
4932 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4933 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4934 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4935 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4936 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4937 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4938 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4939 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4940 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4941 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4942 }
4943
4944 free (shdrs);
049b0c3a 4945 return TRUE;
252b5132
RH		 4946}
4947
049b0c3a
NC		 4948static bfd_boolean
4949get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 4950{
2cf0635d
NC		 4951 Elf64_External_Shdr * shdrs;
4952 Elf_Internal_Shdr * internal;
b34976b6 4953 unsigned int i;
049b0c3a
NC		 4954 unsigned int size = elf_header.e_shentsize;
4955 unsigned int num = probe ? 1 : elf_header.e_shnum;
4956
4957 /* PR binutils/17531: Cope with unexpected section header sizes. */
4958 if (size == 0 || num == 0)
4959 return FALSE;
4960 if (size < sizeof * shdrs)
4961 {
4962 if (! probe)
4963 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4964 return FALSE;
4965 }
4966 if (! probe && size > sizeof * shdrs)
4967 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 4968
3f5e193b 4969 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 4970 size, num,
4971 probe ? NULL : _("section headers"));
4972 if (shdrs == NULL)
4973 return FALSE;
9ea033b2 4974
049b0c3a
NC		 4975 if (section_headers != NULL)
4976 free (section_headers);
3f5e193b
NC		 4977 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4978 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 4979 if (section_headers == NULL)
4980 {
049b0c3a 4981 if (! probe)
8b73c356 4982 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 4983 return FALSE;
9ea033b2
NC		 4984 }
4985
4986 for (i = 0, internal = section_headers;
560f3c1c 4987 i < num;
b34976b6 4988 i++, internal++)
9ea033b2
NC		 4989 {
4990 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4991 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 4992 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4993 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4994 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4995 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 4996 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4997 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4998 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4999 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5000 }
5001
5002 free (shdrs);
049b0c3a 5003 return TRUE;
9ea033b2
NC		 5004}
5005
252b5132 5006static Elf_Internal_Sym *
ba5cdace
NC		 5007get_32bit_elf_symbols (FILE * file,
5008 Elf_Internal_Shdr * section,
5009 unsigned long * num_syms_return)
252b5132 5010{
ba5cdace 5011 unsigned long number = 0;
dd24e3da 5012 Elf32_External_Sym * esyms = NULL;
ba5cdace 5013 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5014 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5015 Elf_Internal_Sym * psym;
b34976b6 5016 unsigned int j;
252b5132 5017
c9c1d674
EG		 5018 if (section->sh_size == 0)
5019 {
5020 if (num_syms_return != NULL)
5021 * num_syms_return = 0;
5022 return NULL;
5023 }
5024
dd24e3da 5025 /* Run some sanity checks first. */
c9c1d674 5026 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5027 {
c9c1d674
EG		 5028 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5029 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5030 goto exit_point;
dd24e3da
NC		 5031 }
5032
f54498b4
NC		 5033 if (section->sh_size > current_file_size)
5034 {
5035 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5036 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5037 goto exit_point;
5038 }
5039
dd24e3da
NC		 5040 number = section->sh_size / section->sh_entsize;
5041
5042 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5043 {
c9c1d674 5044 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5045 (unsigned long) section->sh_size,
5046 printable_section_name (section),
5047 (unsigned long) section->sh_entsize);
ba5cdace 5048 goto exit_point;
dd24e3da
NC		 5049 }
5050
3f5e193b
NC		 5051 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5052 section->sh_size, _("symbols"));
dd24e3da 5053 if (esyms == NULL)
ba5cdace 5054 goto exit_point;
252b5132 5055
6a40cf0c
NC		 5056 {
5057 elf_section_list * entry;
5058
5059 shndx = NULL;
5060 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5061 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5062 {
6a40cf0c
NC		 5063 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5064 entry->hdr->sh_offset,
5065 1, entry->hdr->sh_size,
5066 _("symbol table section indicies"));
5067 if (shndx == NULL)
5068 goto exit_point;
5069 /* PR17531: file: heap-buffer-overflow */
5070 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5071 {
5072 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5073 printable_section_name (entry->hdr),
5074 (unsigned long) entry->hdr->sh_size,
5075 (unsigned long) section->sh_size);
5076 goto exit_point;
5077 }
c9c1d674 5078 }
6a40cf0c 5079 }
9ad5cbcf 5080
3f5e193b 5081 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5082
5083 if (isyms == NULL)
5084 {
8b73c356
NC		 5085 error (_("Out of memory reading %lu symbols\n"),
5086 (unsigned long) number);
dd24e3da 5087 goto exit_point;
252b5132
RH		 5088 }
5089
dd24e3da 5090 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5091 {
5092 psym->st_name = BYTE_GET (esyms[j].st_name);
5093 psym->st_value = BYTE_GET (esyms[j].st_value);
5094 psym->st_size = BYTE_GET (esyms[j].st_size);
5095 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5096 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5097 psym->st_shndx
5098 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5099 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5100 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5101 psym->st_info = BYTE_GET (esyms[j].st_info);
5102 psym->st_other = BYTE_GET (esyms[j].st_other);
5103 }
5104
dd24e3da 5105 exit_point:
ba5cdace 5106 if (shndx != NULL)
9ad5cbcf 5107 free (shndx);
ba5cdace 5108 if (esyms != NULL)
dd24e3da 5109 free (esyms);
252b5132 5110
ba5cdace
NC		 5111 if (num_syms_return != NULL)
5112 * num_syms_return = isyms == NULL ? 0 : number;
5113
252b5132
RH		 5114 return isyms;
5115}
5116
9ea033b2 5117static Elf_Internal_Sym *
ba5cdace
NC		 5118get_64bit_elf_symbols (FILE * file,
5119 Elf_Internal_Shdr * section,
5120 unsigned long * num_syms_return)
9ea033b2 5121{
ba5cdace
NC		 5122 unsigned long number = 0;
5123 Elf64_External_Sym * esyms = NULL;
5124 Elf_External_Sym_Shndx * shndx = NULL;
5125 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5126 Elf_Internal_Sym * psym;
b34976b6 5127 unsigned int j;
9ea033b2 5128
c9c1d674
EG		 5129 if (section->sh_size == 0)
5130 {
5131 if (num_syms_return != NULL)
5132 * num_syms_return = 0;
5133 return NULL;
5134 }
5135
dd24e3da 5136 /* Run some sanity checks first. */
c9c1d674 5137 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5138 {
c9c1d674 5139 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5140 printable_section_name (section),
5141 (unsigned long) section->sh_entsize);
ba5cdace 5142 goto exit_point;
dd24e3da
NC		 5143 }
5144
f54498b4
NC		 5145 if (section->sh_size > current_file_size)
5146 {
5147 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5148 printable_section_name (section),
5149 (unsigned long) section->sh_size);
f54498b4
NC		 5150 goto exit_point;
5151 }
5152
dd24e3da
NC		 5153 number = section->sh_size / section->sh_entsize;
5154
5155 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5156 {
c9c1d674 5157 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5158 (unsigned long) section->sh_size,
5159 printable_section_name (section),
5160 (unsigned long) section->sh_entsize);
ba5cdace 5161 goto exit_point;
dd24e3da
NC		 5162 }
5163
3f5e193b
NC		 5164 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5165 section->sh_size, _("symbols"));
a6e9f9df 5166 if (!esyms)
ba5cdace 5167 goto exit_point;
9ea033b2 5168
6a40cf0c
NC		 5169 {
5170 elf_section_list * entry;
5171
5172 shndx = NULL;
5173 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5174 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5175 {
6a40cf0c
NC		 5176 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5177 entry->hdr->sh_offset,
5178 1, entry->hdr->sh_size,
5179 _("symbol table section indicies"));
5180 if (shndx == NULL)
5181 goto exit_point;
5182 /* PR17531: file: heap-buffer-overflow */
5183 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5184 {
5185 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5186 printable_section_name (entry->hdr),
5187 (unsigned long) entry->hdr->sh_size,
5188 (unsigned long) section->sh_size);
5189 goto exit_point;
5190 }
c9c1d674 5191 }
6a40cf0c 5192 }
9ad5cbcf 5193
3f5e193b 5194 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5195
5196 if (isyms == NULL)
5197 {
8b73c356
NC		 5198 error (_("Out of memory reading %lu symbols\n"),
5199 (unsigned long) number);
ba5cdace 5200 goto exit_point;
9ea033b2
NC		 5201 }
5202
ba5cdace 5203 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5204 {
5205 psym->st_name = BYTE_GET (esyms[j].st_name);
5206 psym->st_info = BYTE_GET (esyms[j].st_info);
5207 psym->st_other = BYTE_GET (esyms[j].st_other);
5208 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5209
4fbb74a6 5210 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5211 psym->st_shndx
5212 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5213 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5214 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5215
66543521
AM		 5216 psym->st_value = BYTE_GET (esyms[j].st_value);
5217 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5218 }
5219
ba5cdace
NC		 5220 exit_point:
5221 if (shndx != NULL)
9ad5cbcf 5222 free (shndx);
ba5cdace
NC		 5223 if (esyms != NULL)
5224 free (esyms);
5225
5226 if (num_syms_return != NULL)
5227 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5228
5229 return isyms;
5230}
5231
d1133906 5232static const char *
d3ba0551 5233get_elf_section_flags (bfd_vma sh_flags)
d1133906 5234{
5477e8a0 5235 static char buff[1024];
2cf0635d 5236 char * p = buff;
8d5ff12c 5237 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5238 int sindex;
5239 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5240 bfd_vma os_flags = 0;
5241 bfd_vma proc_flags = 0;
5242 bfd_vma unknown_flags = 0;
148b93f2 5243 static const struct
5477e8a0 5244 {
2cf0635d 5245 const char * str;
5477e8a0
L		 5246 int len;
5247 }
5248 flags [] =
5249 {
cfcac11d
NC		 5250 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5251 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5252 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5253 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5254 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5255 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5256 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5257 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5258 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5259 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5260 /* IA-64 specific. */
5261 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5262 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5263 /* IA-64 OpenVMS specific. */
5264 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5265 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5266 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5267 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5268 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5269 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5270 /* Generic. */
cfcac11d 5271 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5272 /* SPARC specific. */
77115a4a
L		 5273 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5274 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5477e8a0
L		 5275 };
5276
5277 if (do_section_details)
5278 {
8d5ff12c
L		 5279 sprintf (buff, "[%*.*lx]: ",
5280 field_size, field_size, (unsigned long) sh_flags);
5281 p += field_size + 4;
5477e8a0 5282 }
76da6bbe 5283
d1133906
NC		 5284 while (sh_flags)
5285 {
5286 bfd_vma flag;
5287
5288 flag = sh_flags & - sh_flags;
5289 sh_flags &= ~ flag;
76da6bbe 5290
5477e8a0 5291 if (do_section_details)
d1133906 5292 {
5477e8a0
L		 5293 switch (flag)
5294 {
91d6fa6a
NC		 5295 case SHF_WRITE: sindex = 0; break;
5296 case SHF_ALLOC: sindex = 1; break;
5297 case SHF_EXECINSTR: sindex = 2; break;
5298 case SHF_MERGE: sindex = 3; break;
5299 case SHF_STRINGS: sindex = 4; break;
5300 case SHF_INFO_LINK: sindex = 5; break;
5301 case SHF_LINK_ORDER: sindex = 6; break;
5302 case SHF_OS_NONCONFORMING: sindex = 7; break;
5303 case SHF_GROUP: sindex = 8; break;
5304 case SHF_TLS: sindex = 9; break;
18ae9cc1 5305 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5306 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5307
5477e8a0 5308 default:
91d6fa6a 5309 sindex = -1;
cfcac11d 5310 switch (elf_header.e_machine)
148b93f2 5311 {
cfcac11d 5312 case EM_IA_64:
148b93f2 5313 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5314 sindex = 10;
148b93f2 5315 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5316 sindex = 11;
148b93f2
NC		 5317#ifdef BFD64
5318 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5319 switch (flag)
5320 {
91d6fa6a
NC		 5321 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5322 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5323 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5324 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5325 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5326 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5327 default: break;
5328 }
5329#endif
cfcac11d
NC		 5330 break;
5331
caa83f8b 5332 case EM_386:
22abe556 5333 case EM_IAMCU:
caa83f8b 5334 case EM_X86_64:
7f502d6c 5335 case EM_L1OM:
7a9068fe 5336 case EM_K1OM:
cfcac11d
NC		 5337 case EM_OLD_SPARCV9:
5338 case EM_SPARC32PLUS:
5339 case EM_SPARCV9:
5340 case EM_SPARC:
18ae9cc1 5341 if (flag == SHF_ORDERED)
91d6fa6a 5342 sindex = 19;
cfcac11d
NC		 5343 break;
5344 default:
5345 break;
148b93f2 5346 }
5477e8a0
L		 5347 }
5348
91d6fa6a 5349 if (sindex != -1)
5477e8a0 5350 {
8d5ff12c
L		 5351 if (p != buff + field_size + 4)
5352 {
5353 if (size < (10 + 2))
bee0ee85
NC		 5354 {
5355 warn (_("Internal error: not enough buffer room for section flag info"));
5356 return _("<unknown>");
5357 }
8d5ff12c
L		 5358 size -= 2;
5359 *p++ = ',';
5360 *p++ = ' ';
5361 }
5362
91d6fa6a
NC		 5363 size -= flags [sindex].len;
5364 p = stpcpy (p, flags [sindex].str);
5477e8a0 5365 }
3b22753a 5366 else if (flag & SHF_MASKOS)
8d5ff12c 5367 os_flags |= flag;
d1133906 5368 else if (flag & SHF_MASKPROC)
8d5ff12c 5369 proc_flags |= flag;
d1133906 5370 else
8d5ff12c 5371 unknown_flags |= flag;
5477e8a0
L		 5372 }
5373 else
5374 {
5375 switch (flag)
5376 {
5377 case SHF_WRITE: *p = 'W'; break;
5378 case SHF_ALLOC: *p = 'A'; break;
5379 case SHF_EXECINSTR: *p = 'X'; break;
5380 case SHF_MERGE: *p = 'M'; break;
5381 case SHF_STRINGS: *p = 'S'; break;
5382 case SHF_INFO_LINK: *p = 'I'; break;
5383 case SHF_LINK_ORDER: *p = 'L'; break;
5384 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5385 case SHF_GROUP: *p = 'G'; break;
5386 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5387 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5388 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5389
5390 default:
8a9036a4 5391 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5392 || elf_header.e_machine == EM_L1OM
5393 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5394 && flag == SHF_X86_64_LARGE)
5395 *p = 'l';
5396 else if (flag & SHF_MASKOS)
5397 {
5398 *p = 'o';
5399 sh_flags &= ~ SHF_MASKOS;
5400 }
5401 else if (flag & SHF_MASKPROC)
5402 {
5403 *p = 'p';
5404 sh_flags &= ~ SHF_MASKPROC;
5405 }
5406 else
5407 *p = 'x';
5408 break;
5409 }
5410 p++;
d1133906
NC		 5411 }
5412 }
76da6bbe 5413
8d5ff12c
L		 5414 if (do_section_details)
5415 {
5416 if (os_flags)
5417 {
5418 size -= 5 + field_size;
5419 if (p != buff + field_size + 4)
5420 {
5421 if (size < (2 + 1))
bee0ee85
NC		 5422 {
5423 warn (_("Internal error: not enough buffer room for section flag info"));
5424 return _("<unknown>");
5425 }
8d5ff12c
L		 5426 size -= 2;
5427 *p++ = ',';
5428 *p++ = ' ';
5429 }
5430 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5431 (unsigned long) os_flags);
5432 p += 5 + field_size;
5433 }
5434 if (proc_flags)
5435 {
5436 size -= 7 + field_size;
5437 if (p != buff + field_size + 4)
5438 {
5439 if (size < (2 + 1))
bee0ee85
NC		 5440 {
5441 warn (_("Internal error: not enough buffer room for section flag info"));
5442 return _("<unknown>");
5443 }
8d5ff12c
L		 5444 size -= 2;
5445 *p++ = ',';
5446 *p++ = ' ';
5447 }
5448 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5449 (unsigned long) proc_flags);
5450 p += 7 + field_size;
5451 }
5452 if (unknown_flags)
5453 {
5454 size -= 10 + field_size;
5455 if (p != buff + field_size + 4)
5456 {
5457 if (size < (2 + 1))
bee0ee85
NC		 5458 {
5459 warn (_("Internal error: not enough buffer room for section flag info"));
5460 return _("<unknown>");
5461 }
8d5ff12c
L		 5462 size -= 2;
5463 *p++ = ',';
5464 *p++ = ' ';
5465 }
2b692964 5466 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5467 (unsigned long) unknown_flags);
5468 p += 10 + field_size;
5469 }
5470 }
5471
e9e44622 5472 *p = '\0';
d1133906
NC		 5473 return buff;
5474}
5475
77115a4a
L		 5476static unsigned int
5477get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5478{
5479 if (is_32bit_elf)
5480 {
5481 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5482 chdr->ch_type = BYTE_GET (echdr->ch_type);
5483 chdr->ch_size = BYTE_GET (echdr->ch_size);
5484 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5485 return sizeof (*echdr);
5486 }
5487 else
5488 {
5489 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5490 chdr->ch_type = BYTE_GET (echdr->ch_type);
5491 chdr->ch_size = BYTE_GET (echdr->ch_size);
5492 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5493 return sizeof (*echdr);
5494 }
5495}
5496
252b5132 5497static int
2cf0635d 5498process_section_headers (FILE * file)
252b5132 5499{
2cf0635d 5500 Elf_Internal_Shdr * section;
b34976b6 5501 unsigned int i;
252b5132
RH		 5502
5503 section_headers = NULL;
5504
5505 if (elf_header.e_shnum == 0)
5506 {
82f2dbf7
NC		 5507 /* PR binutils/12467. */
5508 if (elf_header.e_shoff != 0)
5509 warn (_("possibly corrupt ELF file header - it has a non-zero"
5510 " section header offset, but no section headers\n"));
5511 else if (do_sections)
252b5132
RH		 5512 printf (_("\nThere are no sections in this file.\n"));
5513
5514 return 1;
5515 }
5516
5517 if (do_sections && !do_header)
9ea033b2 5518 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5519 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5520
9ea033b2
NC		 5521 if (is_32bit_elf)
5522 {
049b0c3a 5523 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5524 return 0;
5525 }
049b0c3a 5526 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5527 return 0;
5528
5529 /* Read in the string table, so that we have names to display. */
0b49d371 5530 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5531 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5532 {
4fbb74a6 5533 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5534
c256ffe7
JJ		 5535 if (section->sh_size != 0)
5536 {
3f5e193b
NC		 5537 string_table = (char *) get_data (NULL, file, section->sh_offset,
5538 1, section->sh_size,
5539 _("string table"));
0de14b54 5540
c256ffe7
JJ		 5541 string_table_length = string_table != NULL ? section->sh_size : 0;
5542 }
252b5132
RH		 5543 }
5544
5545 /* Scan the sections for the dynamic symbol table
e3c8793a 5546 and dynamic string table and debug sections. */
252b5132
RH		 5547 dynamic_symbols = NULL;
5548 dynamic_strings = NULL;
5549 dynamic_syminfo = NULL;
6a40cf0c 5550 symtab_shndx_list = NULL;
103f02d3 5551
89fac5e3
RS		 5552 eh_addr_size = is_32bit_elf ? 4 : 8;
5553 switch (elf_header.e_machine)
5554 {
5555 case EM_MIPS:
5556 case EM_MIPS_RS3_LE:
5557 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5558 FDE addresses. However, the ABI also has a semi-official ILP32
5559 variant for which the normal FDE address size rules apply.
5560
5561 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5562 section, where XX is the size of longs in bits. Unfortunately,
5563 earlier compilers provided no way of distinguishing ILP32 objects
5564 from LP64 objects, so if there's any doubt, we should assume that
5565 the official LP64 form is being used. */
5566 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5567 && find_section (".gcc_compiled_long32") == NULL)
5568 eh_addr_size = 8;
5569 break;
0f56a26a
DD		 5570
5571 case EM_H8_300:
5572 case EM_H8_300H:
5573 switch (elf_header.e_flags & EF_H8_MACH)
5574 {
5575 case E_H8_MACH_H8300:
5576 case E_H8_MACH_H8300HN:
5577 case E_H8_MACH_H8300SN:
5578 case E_H8_MACH_H8300SXN:
5579 eh_addr_size = 2;
5580 break;
5581 case E_H8_MACH_H8300H:
5582 case E_H8_MACH_H8300S:
5583 case E_H8_MACH_H8300SX:
5584 eh_addr_size = 4;
5585 break;
5586 }
f4236fe4
DD		 5587 break;
5588
ff7eeb89 5589 case EM_M32C_OLD:
f4236fe4
DD		 5590 case EM_M32C:
5591 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5592 {
5593 case EF_M32C_CPU_M16C:
5594 eh_addr_size = 2;
5595 break;
5596 }
5597 break;
89fac5e3
RS		 5598 }
5599
76ca31c0
NC		 5600#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5601 do \
5602 { \
5603 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5604 if (section->sh_entsize != expected_entsize) \
9dd3a467 5605 { \
76ca31c0
NC		 5606 char buf[40]; \
5607 sprintf_vma (buf, section->sh_entsize); \
5608 /* Note: coded this way so that there is a single string for \
5609 translation. */ \
5610 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5611 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5612 (unsigned) expected_entsize); \
9dd3a467 5613 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5614 } \
5615 } \
08d8fa11 5616 while (0)
9dd3a467
NC		 5617
5618#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5619 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5620 sizeof (Elf64_External_##type))
5621
252b5132
RH		 5622 for (i = 0, section = section_headers;
5623 i < elf_header.e_shnum;
b34976b6 5624 i++, section++)
252b5132 5625 {
2cf0635d 5626 char * name = SECTION_NAME (section);
252b5132
RH		 5627
5628 if (section->sh_type == SHT_DYNSYM)
5629 {
5630 if (dynamic_symbols != NULL)
5631 {
5632 error (_("File contains multiple dynamic symbol tables\n"));
5633 continue;
5634 }
5635
08d8fa11 5636 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5637 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5638 }
5639 else if (section->sh_type == SHT_STRTAB
18bd398b 5640 && streq (name, ".dynstr"))
252b5132
RH		 5641 {
5642 if (dynamic_strings != NULL)
5643 {
5644 error (_("File contains multiple dynamic string tables\n"));
5645 continue;
5646 }
5647
3f5e193b
NC		 5648 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5649 1, section->sh_size,
5650 _("dynamic strings"));
59245841 5651 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5652 }
9ad5cbcf
AM		 5653 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5654 {
6a40cf0c
NC		 5655 elf_section_list * entry = xmalloc (sizeof * entry);
5656 entry->hdr = section;
5657 entry->next = symtab_shndx_list;
5658 symtab_shndx_list = entry;
9ad5cbcf 5659 }
08d8fa11
JJ		 5660 else if (section->sh_type == SHT_SYMTAB)
5661 CHECK_ENTSIZE (section, i, Sym);
5662 else if (section->sh_type == SHT_GROUP)
5663 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5664 else if (section->sh_type == SHT_REL)
5665 CHECK_ENTSIZE (section, i, Rel);
5666 else if (section->sh_type == SHT_RELA)
5667 CHECK_ENTSIZE (section, i, Rela);
252b5132 5668 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5669 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5670 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5671 || do_debug_str || do_debug_loc || do_debug_ranges
5672 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5673 && (const_strneq (name, ".debug_")
5674 || const_strneq (name, ".zdebug_")))
252b5132 5675 {
1b315056
CS		 5676 if (name[1] == 'z')
5677 name += sizeof (".zdebug_") - 1;
5678 else
5679 name += sizeof (".debug_") - 1;
252b5132
RH		 5680
5681 if (do_debugging
4723351a
CC		 5682 || (do_debug_info && const_strneq (name, "info"))
5683 || (do_debug_info && const_strneq (name, "types"))
5684 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5685 || (do_debug_lines && strcmp (name, "line") == 0)
5686 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5687 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5688 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5689 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5690 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5691 || (do_debug_aranges && const_strneq (name, "aranges"))
5692 || (do_debug_ranges && const_strneq (name, "ranges"))
5693 || (do_debug_frames && const_strneq (name, "frame"))
5694 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5695 || (do_debug_macinfo && const_strneq (name, "macro"))
5696 || (do_debug_str && const_strneq (name, "str"))
5697 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5698 || (do_debug_addr && const_strneq (name, "addr"))
5699 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5700 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5701 )
09c11c86 5702 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5703 }
a262ae96 5704 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5705 else if ((do_debugging || do_debug_info)
0112cd26 5706 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5707 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5708 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5709 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5710 else if (do_gdb_index && streq (name, ".gdb_index"))
5711 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5712 /* Trace sections for Itanium VMS. */
5713 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5714 || do_trace_aranges)
5715 && const_strneq (name, ".trace_"))
5716 {
5717 name += sizeof (".trace_") - 1;
5718
5719 if (do_debugging
5720 || (do_trace_info && streq (name, "info"))
5721 || (do_trace_abbrevs && streq (name, "abbrev"))
5722 || (do_trace_aranges && streq (name, "aranges"))
5723 )
5724 request_dump_bynumber (i, DEBUG_DUMP);
5725 }
252b5132
RH		 5726 }
5727
5728 if (! do_sections)
5729 return 1;
5730
3a1a2036
NC		 5731 if (elf_header.e_shnum > 1)
5732 printf (_("\nSection Headers:\n"));
5733 else
5734 printf (_("\nSection Header:\n"));
76da6bbe 5735
f7a99963 5736 if (is_32bit_elf)
595cf52e 5737 {
5477e8a0 5738 if (do_section_details)
595cf52e
L		 5739 {
5740 printf (_(" [Nr] Name\n"));
5477e8a0 5741 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5742 }
5743 else
5744 printf
5745 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5746 }
d974e256 5747 else if (do_wide)
595cf52e 5748 {
5477e8a0 5749 if (do_section_details)
595cf52e
L		 5750 {
5751 printf (_(" [Nr] Name\n"));
5477e8a0 5752 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5753 }
5754 else
5755 printf
5756 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5757 }
f7a99963
NC		 5758 else
5759 {
5477e8a0 5760 if (do_section_details)
595cf52e
L		 5761 {
5762 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5763 printf (_(" Type Address Offset Link\n"));
5764 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5765 }
5766 else
5767 {
5768 printf (_(" [Nr] Name Type Address Offset\n"));
5769 printf (_(" Size EntSize Flags Link Info Align\n"));
5770 }
f7a99963 5771 }
252b5132 5772
5477e8a0
L		 5773 if (do_section_details)
5774 printf (_(" Flags\n"));
5775
252b5132
RH		 5776 for (i = 0, section = section_headers;
5777 i < elf_header.e_shnum;
b34976b6 5778 i++, section++)
252b5132 5779 {
7bfd842d 5780 printf (" [%2u] ", i);
5477e8a0 5781 if (do_section_details)
74e1a04b 5782 printf ("%s\n ", printable_section_name (section));
595cf52e 5783 else
74e1a04b 5784 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5785
ea52a088
NC		 5786 printf (do_wide ? " %-15s " : " %-15.15s ",
5787 get_section_type_name (section->sh_type));
0b4362b0 5788
f7a99963
NC		 5789 if (is_32bit_elf)
5790 {
cfcac11d
NC		 5791 const char * link_too_big = NULL;
5792
f7a99963 5793 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5794
f7a99963
NC		 5795 printf ( " %6.6lx %6.6lx %2.2lx",
5796 (unsigned long) section->sh_offset,
5797 (unsigned long) section->sh_size,
5798 (unsigned long) section->sh_entsize);
d1133906 5799
5477e8a0
L		 5800 if (do_section_details)
5801 fputs (" ", stdout);
5802 else
5803 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5804
cfcac11d
NC		 5805 if (section->sh_link >= elf_header.e_shnum)
5806 {
5807 link_too_big = "";
5808 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5809 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5810 switch (elf_header.e_machine)
5811 {
caa83f8b 5812 case EM_386:
22abe556 5813 case EM_IAMCU:
caa83f8b 5814 case EM_X86_64:
7f502d6c 5815 case EM_L1OM:
7a9068fe 5816 case EM_K1OM:
cfcac11d
NC		 5817 case EM_OLD_SPARCV9:
5818 case EM_SPARC32PLUS:
5819 case EM_SPARCV9:
5820 case EM_SPARC:
5821 if (section->sh_link == (SHN_BEFORE & 0xffff))
5822 link_too_big = "BEFORE";
5823 else if (section->sh_link == (SHN_AFTER & 0xffff))
5824 link_too_big = "AFTER";
5825 break;
5826 default:
5827 break;
5828 }
5829 }
5830
5831 if (do_section_details)
5832 {
5833 if (link_too_big != NULL && * link_too_big)
5834 printf ("<%s> ", link_too_big);
5835 else
5836 printf ("%2u ", section->sh_link);
5837 printf ("%3u %2lu\n", section->sh_info,
5838 (unsigned long) section->sh_addralign);
5839 }
5840 else
5841 printf ("%2u %3u %2lu\n",
5842 section->sh_link,
5843 section->sh_info,
5844 (unsigned long) section->sh_addralign);
5845
5846 if (link_too_big && ! * link_too_big)
5847 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5848 i, section->sh_link);
f7a99963 5849 }
d974e256
JJ		 5850 else if (do_wide)
5851 {
5852 print_vma (section->sh_addr, LONG_HEX);
5853
5854 if ((long) section->sh_offset == section->sh_offset)
5855 printf (" %6.6lx", (unsigned long) section->sh_offset);
5856 else
5857 {
5858 putchar (' ');
5859 print_vma (section->sh_offset, LONG_HEX);
5860 }
5861
5862 if ((unsigned long) section->sh_size == section->sh_size)
5863 printf (" %6.6lx", (unsigned long) section->sh_size);
5864 else
5865 {
5866 putchar (' ');
5867 print_vma (section->sh_size, LONG_HEX);
5868 }
5869
5870 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5871 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5872 else
5873 {
5874 putchar (' ');
5875 print_vma (section->sh_entsize, LONG_HEX);
5876 }
5877
5477e8a0
L		 5878 if (do_section_details)
5879 fputs (" ", stdout);
5880 else
5881 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 5882
72de5009 5883 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 5884
5885 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 5886 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 5887 else
5888 {
5889 print_vma (section->sh_addralign, DEC);
5890 putchar ('\n');
5891 }
5892 }
5477e8a0 5893 else if (do_section_details)
595cf52e 5894 {
5477e8a0 5895 printf (" %-15.15s ",
595cf52e 5896 get_section_type_name (section->sh_type));
595cf52e
L		 5897 print_vma (section->sh_addr, LONG_HEX);
5898 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 5899 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 5900 else
5901 {
5902 printf (" ");
5903 print_vma (section->sh_offset, LONG_HEX);
5904 }
72de5009 5905 printf (" %u\n ", section->sh_link);
595cf52e 5906 print_vma (section->sh_size, LONG_HEX);
5477e8a0 5907 putchar (' ');
595cf52e
L		 5908 print_vma (section->sh_entsize, LONG_HEX);
5909
72de5009
AM		 5910 printf (" %-16u %lu\n",
5911 section->sh_info,
595cf52e
L		 5912 (unsigned long) section->sh_addralign);
5913 }
f7a99963
NC		 5914 else
5915 {
5916 putchar (' ');
5917 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 5918 if ((long) section->sh_offset == section->sh_offset)
5919 printf (" %8.8lx", (unsigned long) section->sh_offset);
5920 else
5921 {
5922 printf (" ");
5923 print_vma (section->sh_offset, LONG_HEX);
5924 }
f7a99963
NC		 5925 printf ("\n ");
5926 print_vma (section->sh_size, LONG_HEX);
5927 printf (" ");
5928 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 5929
d1133906 5930 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5931
72de5009
AM		 5932 printf (" %2u %3u %lu\n",
5933 section->sh_link,
5934 section->sh_info,
f7a99963
NC		 5935 (unsigned long) section->sh_addralign);
5936 }
5477e8a0
L		 5937
5938 if (do_section_details)
77115a4a
L		 5939 {
5940 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5941 if ((section->sh_flags & SHF_COMPRESSED) != 0)
5942 {
5943 /* Minimum section size is 12 bytes for 32-bit compression
5944 header + 12 bytes for compressed data header. */
5945 unsigned char buf[24];
5946 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
5947 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
5948 sizeof (buf), _("compression header")))
5949 {
5950 Elf_Internal_Chdr chdr;
5951 get_compression_header (&chdr, buf);
5952 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
5953 printf (" ZLIB, ");
5954 else
5955 printf (_(" [<unknown>: 0x%x], "),
5956 chdr.ch_type);
5957 print_vma (chdr.ch_size, LONG_HEX);
5958 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
5959 }
5960 }
5961 }
252b5132
RH		 5962 }
5963
5477e8a0 5964 if (!do_section_details)
3dbcc61d
NC		 5965 {
5966 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 5967 || elf_header.e_machine == EM_L1OM
5968 || elf_header.e_machine == EM_K1OM)
3dbcc61d
NC		 5969 printf (_("Key to Flags:\n\
5970 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5971 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5972 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5973 else
5974 printf (_("Key to Flags:\n\
e3c8793a 5975 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
1d0055ea 5976 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
e3c8793a 5977 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
0b4362b0 5978 }
d1133906 5979
252b5132
RH		 5980 return 1;
5981}
5982
f5842774
L		 5983static const char *
5984get_group_flags (unsigned int flags)
5985{
5986 static char buff[32];
5987 switch (flags)
5988 {
220453ec
AM		 5989 case 0:
5990 return "";
5991
f5842774 5992 case GRP_COMDAT:
220453ec 5993 return "COMDAT ";
f5842774
L		 5994
5995 default:
220453ec 5996 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 5997 break;
5998 }
5999 return buff;
6000}
6001
6002static int
2cf0635d 6003process_section_groups (FILE * file)
f5842774 6004{
2cf0635d 6005 Elf_Internal_Shdr * section;
f5842774 6006 unsigned int i;
2cf0635d
NC		 6007 struct group * group;
6008 Elf_Internal_Shdr * symtab_sec;
6009 Elf_Internal_Shdr * strtab_sec;
6010 Elf_Internal_Sym * symtab;
ba5cdace 6011 unsigned long num_syms;
2cf0635d 6012 char * strtab;
c256ffe7 6013 size_t strtab_size;
d1f5c6e3
L		 6014
6015 /* Don't process section groups unless needed. */
6016 if (!do_unwind && !do_section_groups)
6017 return 1;
f5842774
L		 6018
6019 if (elf_header.e_shnum == 0)
6020 {
6021 if (do_section_groups)
82f2dbf7 6022 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6023
6024 return 1;
6025 }
6026
6027 if (section_headers == NULL)
6028 {
6029 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6030 /* PR 13622: This can happen with a corrupt ELF header. */
6031 return 0;
f5842774
L		 6032 }
6033
3f5e193b
NC		 6034 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6035 sizeof (struct group *));
e4b17d5c
L		 6036
6037 if (section_headers_groups == NULL)
6038 {
8b73c356
NC		 6039 error (_("Out of memory reading %u section group headers\n"),
6040 elf_header.e_shnum);
e4b17d5c
L		 6041 return 0;
6042 }
6043
f5842774 6044 /* Scan the sections for the group section. */
d1f5c6e3 6045 group_count = 0;
f5842774
L		 6046 for (i = 0, section = section_headers;
6047 i < elf_header.e_shnum;
6048 i++, section++)
e4b17d5c
L		 6049 if (section->sh_type == SHT_GROUP)
6050 group_count++;
6051
d1f5c6e3
L		 6052 if (group_count == 0)
6053 {
6054 if (do_section_groups)
6055 printf (_("\nThere are no section groups in this file.\n"));
6056
6057 return 1;
6058 }
6059
3f5e193b 6060 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6061
6062 if (section_groups == NULL)
6063 {
8b73c356
NC		 6064 error (_("Out of memory reading %lu groups\n"),
6065 (unsigned long) group_count);
e4b17d5c
L		 6066 return 0;
6067 }
6068
d1f5c6e3
L		 6069 symtab_sec = NULL;
6070 strtab_sec = NULL;
6071 symtab = NULL;
ba5cdace 6072 num_syms = 0;
d1f5c6e3 6073 strtab = NULL;
c256ffe7 6074 strtab_size = 0;
e4b17d5c
L		 6075 for (i = 0, section = section_headers, group = section_groups;
6076 i < elf_header.e_shnum;
6077 i++, section++)
f5842774
L		 6078 {
6079 if (section->sh_type == SHT_GROUP)
6080 {
74e1a04b
NC		 6081 const char * name = printable_section_name (section);
6082 const char * group_name;
2cf0635d
NC		 6083 unsigned char * start;
6084 unsigned char * indices;
f5842774 6085 unsigned int entry, j, size;
2cf0635d
NC		 6086 Elf_Internal_Shdr * sec;
6087 Elf_Internal_Sym * sym;
f5842774
L		 6088
6089 /* Get the symbol table. */
4fbb74a6
AM		 6090 if (section->sh_link >= elf_header.e_shnum
6091 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6092 != SHT_SYMTAB))
f5842774
L		 6093 {
6094 error (_("Bad sh_link in group section `%s'\n"), name);
6095 continue;
6096 }
d1f5c6e3
L		 6097
6098 if (symtab_sec != sec)
6099 {
6100 symtab_sec = sec;
6101 if (symtab)
6102 free (symtab);
ba5cdace 6103 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6104 }
f5842774 6105
dd24e3da
NC		 6106 if (symtab == NULL)
6107 {
6108 error (_("Corrupt header in group section `%s'\n"), name);
6109 continue;
6110 }
6111
ba5cdace
NC		 6112 if (section->sh_info >= num_syms)
6113 {
6114 error (_("Bad sh_info in group section `%s'\n"), name);
6115 continue;
6116 }
6117
f5842774
L		 6118 sym = symtab + section->sh_info;
6119
6120 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6121 {
4fbb74a6
AM		 6122 if (sym->st_shndx == 0
6123 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6124 {
6125 error (_("Bad sh_info in group section `%s'\n"), name);
6126 continue;
6127 }
ba2685cc 6128
4fbb74a6 6129 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6130 strtab_sec = NULL;
6131 if (strtab)
6132 free (strtab);
f5842774 6133 strtab = NULL;
c256ffe7 6134 strtab_size = 0;
f5842774
L		 6135 }
6136 else
6137 {
6138 /* Get the string table. */
4fbb74a6 6139 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6140 {
6141 strtab_sec = NULL;
6142 if (strtab)
6143 free (strtab);
6144 strtab = NULL;
6145 strtab_size = 0;
6146 }
6147 else if (strtab_sec
4fbb74a6 6148 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6149 {
6150 strtab_sec = sec;
6151 if (strtab)
6152 free (strtab);
071436c6 6153
3f5e193b 6154 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6155 1, strtab_sec->sh_size,
6156 _("string table"));
c256ffe7 6157 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6158 }
c256ffe7 6159 group_name = sym->st_name < strtab_size
2b692964 6160 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6161 }
6162
c9c1d674
EG		 6163 /* PR 17531: file: loop. */
6164 if (section->sh_entsize > section->sh_size)
6165 {
6166 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6167 printable_section_name (section),
8066deb1
AM		 6168 (unsigned long) section->sh_entsize,
6169 (unsigned long) section->sh_size);
c9c1d674
EG		 6170 break;
6171 }
6172
3f5e193b
NC		 6173 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6174 1, section->sh_size,
6175 _("section data"));
59245841
NC		 6176 if (start == NULL)
6177 continue;
f5842774
L		 6178
6179 indices = start;
6180 size = (section->sh_size / section->sh_entsize) - 1;
6181 entry = byte_get (indices, 4);
6182 indices += 4;
e4b17d5c
L		 6183
6184 if (do_section_groups)
6185 {
2b692964 6186 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6187 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6188
e4b17d5c
L		 6189 printf (_(" [Index] Name\n"));
6190 }
6191
6192 group->group_index = i;
6193
f5842774
L		 6194 for (j = 0; j < size; j++)
6195 {
2cf0635d 6196 struct group_list * g;
e4b17d5c 6197
f5842774
L		 6198 entry = byte_get (indices, 4);
6199 indices += 4;
6200
4fbb74a6 6201 if (entry >= elf_header.e_shnum)
391cb864 6202 {
57028622
NC		 6203 static unsigned num_group_errors = 0;
6204
6205 if (num_group_errors ++ < 10)
6206 {
6207 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6208 entry, i, elf_header.e_shnum - 1);
6209 if (num_group_errors == 10)
6210 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6211 }
391cb864
L		 6212 continue;
6213 }
391cb864 6214
4fbb74a6 6215 if (section_headers_groups [entry] != NULL)
e4b17d5c 6216 {
d1f5c6e3
L		 6217 if (entry)
6218 {
57028622
NC		 6219 static unsigned num_errs = 0;
6220
6221 if (num_errs ++ < 10)
6222 {
6223 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6224 entry, i,
6225 section_headers_groups [entry]->group_index);
6226 if (num_errs == 10)
6227 warn (_("Further error messages about already contained group sections suppressed\n"));
6228 }
d1f5c6e3
L		 6229 continue;
6230 }
6231 else
6232 {
6233 /* Intel C/C++ compiler may put section 0 in a
6234 section group. We just warn it the first time
6235 and ignore it afterwards. */
6236 static int warned = 0;
6237 if (!warned)
6238 {
6239 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6240 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6241 warned++;
6242 }
6243 }
e4b17d5c
L		 6244 }
6245
4fbb74a6 6246 section_headers_groups [entry] = group;
e4b17d5c
L		 6247
6248 if (do_section_groups)
6249 {
4fbb74a6 6250 sec = section_headers + entry;
74e1a04b 6251 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6252 }
6253
3f5e193b 6254 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6255 g->section_index = entry;
6256 g->next = group->root;
6257 group->root = g;
f5842774
L		 6258 }
6259
f5842774
L		 6260 if (start)
6261 free (start);
e4b17d5c
L		 6262
6263 group++;
f5842774
L		 6264 }
6265 }
6266
d1f5c6e3
L		 6267 if (symtab)
6268 free (symtab);
6269 if (strtab)
6270 free (strtab);
f5842774
L		 6271 return 1;
6272}
6273
28f997cf
TG		 6274/* Data used to display dynamic fixups. */
6275
6276struct ia64_vms_dynfixup
6277{
6278 bfd_vma needed_ident; /* Library ident number. */
6279 bfd_vma needed; /* Index in the dstrtab of the library name. */
6280 bfd_vma fixup_needed; /* Index of the library. */
6281 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6282 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6283};
6284
6285/* Data used to display dynamic relocations. */
6286
6287struct ia64_vms_dynimgrela
6288{
6289 bfd_vma img_rela_cnt; /* Number of relocations. */
6290 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6291};
6292
6293/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6294 library). */
6295
6296static void
6297dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6298 const char *strtab, unsigned int strtab_sz)
6299{
6300 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6301 long i;
6302 const char *lib_name;
6303
6304 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6305 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6306 _("dynamic section image fixups"));
6307 if (!imfs)
6308 return;
6309
6310 if (fixup->needed < strtab_sz)
6311 lib_name = strtab + fixup->needed;
6312 else
6313 {
6314 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6315 (unsigned long) fixup->needed);
28f997cf
TG		 6316 lib_name = "???";
6317 }
6318 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6319 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6320 printf
6321 (_("Seg Offset Type SymVec DataType\n"));
6322
6323 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6324 {
6325 unsigned int type;
6326 const char *rtype;
6327
6328 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6329 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6330 type = BYTE_GET (imfs [i].type);
6331 rtype = elf_ia64_reloc_type (type);
6332 if (rtype == NULL)
6333 printf (" 0x%08x ", type);
6334 else
6335 printf (" %-32s ", rtype);
6336 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6337 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6338 }
6339
6340 free (imfs);
6341}
6342
6343/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6344
6345static void
6346dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6347{
6348 Elf64_External_VMS_IMAGE_RELA *imrs;
6349 long i;
6350
6351 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6352 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6353 _("dynamic section image relocations"));
28f997cf
TG		 6354 if (!imrs)
6355 return;
6356
6357 printf (_("\nImage relocs\n"));
6358 printf
6359 (_("Seg Offset Type Addend Seg Sym Off\n"));
6360
6361 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6362 {
6363 unsigned int type;
6364 const char *rtype;
6365
6366 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6367 printf ("%08" BFD_VMA_FMT "x ",
6368 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6369 type = BYTE_GET (imrs [i].type);
6370 rtype = elf_ia64_reloc_type (type);
6371 if (rtype == NULL)
6372 printf ("0x%08x ", type);
6373 else
6374 printf ("%-31s ", rtype);
6375 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6376 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6377 printf ("%08" BFD_VMA_FMT "x\n",
6378 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6379 }
6380
6381 free (imrs);
6382}
6383
6384/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6385
6386static int
6387process_ia64_vms_dynamic_relocs (FILE *file)
6388{
6389 struct ia64_vms_dynfixup fixup;
6390 struct ia64_vms_dynimgrela imgrela;
6391 Elf_Internal_Dyn *entry;
6392 int res = 0;
6393 bfd_vma strtab_off = 0;
6394 bfd_vma strtab_sz = 0;
6395 char *strtab = NULL;
6396
6397 memset (&fixup, 0, sizeof (fixup));
6398 memset (&imgrela, 0, sizeof (imgrela));
6399
6400 /* Note: the order of the entries is specified by the OpenVMS specs. */
6401 for (entry = dynamic_section;
6402 entry < dynamic_section + dynamic_nent;
6403 entry++)
6404 {
6405 switch (entry->d_tag)
6406 {
6407 case DT_IA_64_VMS_STRTAB_OFFSET:
6408 strtab_off = entry->d_un.d_val;
6409 break;
6410 case DT_STRSZ:
6411 strtab_sz = entry->d_un.d_val;
6412 if (strtab == NULL)
6413 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6414 1, strtab_sz, _("dynamic string section"));
6415 break;
6416
6417 case DT_IA_64_VMS_NEEDED_IDENT:
6418 fixup.needed_ident = entry->d_un.d_val;
6419 break;
6420 case DT_NEEDED:
6421 fixup.needed = entry->d_un.d_val;
6422 break;
6423 case DT_IA_64_VMS_FIXUP_NEEDED:
6424 fixup.fixup_needed = entry->d_un.d_val;
6425 break;
6426 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6427 fixup.fixup_rela_cnt = entry->d_un.d_val;
6428 break;
6429 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6430 fixup.fixup_rela_off = entry->d_un.d_val;
6431 res++;
6432 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6433 break;
6434
6435 case DT_IA_64_VMS_IMG_RELA_CNT:
6436 imgrela.img_rela_cnt = entry->d_un.d_val;
6437 break;
6438 case DT_IA_64_VMS_IMG_RELA_OFF:
6439 imgrela.img_rela_off = entry->d_un.d_val;
6440 res++;
6441 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6442 break;
6443
6444 default:
6445 break;
6446 }
6447 }
6448
6449 if (strtab != NULL)
6450 free (strtab);
6451
6452 return res;
6453}
6454
85b1c36d 6455static struct
566b0d53 6456{
2cf0635d 6457 const char * name;
566b0d53
L		 6458 int reloc;
6459 int size;
6460 int rela;
6461} dynamic_relocations [] =
6462{
6463 { "REL", DT_REL, DT_RELSZ, FALSE },
6464 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6465 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6466};
6467
252b5132 6468/* Process the reloc section. */
18bd398b 6469
252b5132 6470static int
2cf0635d 6471process_relocs (FILE * file)
252b5132 6472{
b34976b6
AM		 6473 unsigned long rel_size;
6474 unsigned long rel_offset;
252b5132
RH		 6475
6476
6477 if (!do_reloc)
6478 return 1;
6479
6480 if (do_using_dynamic)
6481 {
566b0d53 6482 int is_rela;
2cf0635d 6483 const char * name;
566b0d53
L		 6484 int has_dynamic_reloc;
6485 unsigned int i;
0de14b54 6486
566b0d53 6487 has_dynamic_reloc = 0;
252b5132 6488
566b0d53 6489 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6490 {
566b0d53
L		 6491 is_rela = dynamic_relocations [i].rela;
6492 name = dynamic_relocations [i].name;
6493 rel_size = dynamic_info [dynamic_relocations [i].size];
6494 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6495
566b0d53
L		 6496 has_dynamic_reloc |= rel_size;
6497
6498 if (is_rela == UNKNOWN)
aa903cfb 6499 {
566b0d53
L		 6500 if (dynamic_relocations [i].reloc == DT_JMPREL)
6501 switch (dynamic_info[DT_PLTREL])
6502 {
6503 case DT_REL:
6504 is_rela = FALSE;
6505 break;
6506 case DT_RELA:
6507 is_rela = TRUE;
6508 break;
6509 }
aa903cfb 6510 }
252b5132 6511
566b0d53
L		 6512 if (rel_size)
6513 {
6514 printf
6515 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6516 name, rel_offset, rel_size);
252b5132 6517
d93f0186
NC		 6518 dump_relocations (file,
6519 offset_from_vma (file, rel_offset, rel_size),
6520 rel_size,
566b0d53 6521 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6522 dynamic_strings, dynamic_strings_length,
6523 is_rela, 1);
566b0d53 6524 }
252b5132 6525 }
566b0d53 6526
28f997cf
TG		 6527 if (is_ia64_vms ())
6528 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6529
566b0d53 6530 if (! has_dynamic_reloc)
252b5132
RH		 6531 printf (_("\nThere are no dynamic relocations in this file.\n"));
6532 }
6533 else
6534 {
2cf0635d 6535 Elf_Internal_Shdr * section;
b34976b6
AM		 6536 unsigned long i;
6537 int found = 0;
252b5132
RH		 6538
6539 for (i = 0, section = section_headers;
6540 i < elf_header.e_shnum;
b34976b6 6541 i++, section++)
252b5132
RH		 6542 {
6543 if ( section->sh_type != SHT_RELA
6544 && section->sh_type != SHT_REL)
6545 continue;
6546
6547 rel_offset = section->sh_offset;
6548 rel_size = section->sh_size;
6549
6550 if (rel_size)
6551 {
2cf0635d 6552 Elf_Internal_Shdr * strsec;
b34976b6 6553 int is_rela;
103f02d3 6554
252b5132
RH		 6555 printf (_("\nRelocation section "));
6556
6557 if (string_table == NULL)
19936277 6558 printf ("%d", section->sh_name);
252b5132 6559 else
74e1a04b 6560 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6561
6562 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6563 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6564
d79b3d50
NC		 6565 is_rela = section->sh_type == SHT_RELA;
6566
4fbb74a6
AM		 6567 if (section->sh_link != 0
6568 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6569 {
2cf0635d
NC		 6570 Elf_Internal_Shdr * symsec;
6571 Elf_Internal_Sym * symtab;
d79b3d50 6572 unsigned long nsyms;
c256ffe7 6573 unsigned long strtablen = 0;
2cf0635d 6574 char * strtab = NULL;
57346661 6575
4fbb74a6 6576 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6577 if (symsec->sh_type != SHT_SYMTAB
6578 && symsec->sh_type != SHT_DYNSYM)
6579 continue;
6580
ba5cdace 6581 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6582
af3fc3bc
AM		 6583 if (symtab == NULL)
6584 continue;
252b5132 6585
4fbb74a6
AM		 6586 if (symsec->sh_link != 0
6587 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6588 {
4fbb74a6 6589 strsec = section_headers + symsec->sh_link;
103f02d3 6590
3f5e193b 6591 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6592 1, strsec->sh_size,
6593 _("string table"));
c256ffe7
JJ		 6594 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6595 }
252b5132 6596
d79b3d50 6597 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6598 symtab, nsyms, strtab, strtablen,
6599 is_rela,
6600 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6601 if (strtab)
6602 free (strtab);
6603 free (symtab);
6604 }
6605 else
6606 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6607 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6608
6609 found = 1;
6610 }
6611 }
6612
6613 if (! found)
6614 printf (_("\nThere are no relocations in this file.\n"));
6615 }
6616
6617 return 1;
6618}
6619
4d6ed7c8
NC		 6620/* An absolute address consists of a section and an offset. If the
6621 section is NULL, the offset itself is the address, otherwise, the
6622 address equals to LOAD_ADDRESS(section) + offset. */
6623
6624struct absaddr
948f632f
DA		 6625{
6626 unsigned short section;
6627 bfd_vma offset;
6628};
4d6ed7c8 6629
1949de15
L		 6630#define ABSADDR(a) \
6631 ((a).section \
6632 ? section_headers [(a).section].sh_addr + (a).offset \
6633 : (a).offset)
6634
948f632f
DA		 6635/* Find the nearest symbol at or below ADDR. Returns the symbol
6636 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6637
4d6ed7c8 6638static void
2cf0635d 6639find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6640 unsigned long nsyms,
6641 const char * strtab,
6642 unsigned long strtab_size,
6643 struct absaddr addr,
6644 const char ** symname,
6645 bfd_vma * offset)
4d6ed7c8 6646{
d3ba0551 6647 bfd_vma dist = 0x100000;
2cf0635d 6648 Elf_Internal_Sym * sym;
948f632f
DA		 6649 Elf_Internal_Sym * beg;
6650 Elf_Internal_Sym * end;
2cf0635d 6651 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6652
0b6ae522 6653 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6654 beg = symtab;
6655 end = symtab + nsyms;
0b6ae522 6656
948f632f 6657 while (beg < end)
4d6ed7c8 6658 {
948f632f
DA		 6659 bfd_vma value;
6660
6661 sym = beg + (end - beg) / 2;
0b6ae522 6662
948f632f 6663 value = sym->st_value;
0b6ae522
DJ		 6664 REMOVE_ARCH_BITS (value);
6665
948f632f 6666 if (sym->st_name != 0
4d6ed7c8 6667 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6668 && addr.offset >= value
6669 && addr.offset - value < dist)
4d6ed7c8
NC		 6670 {
6671 best = sym;
0b6ae522 6672 dist = addr.offset - value;
4d6ed7c8
NC		 6673 if (!dist)
6674 break;
6675 }
948f632f
DA		 6676
6677 if (addr.offset < value)
6678 end = sym;
6679 else
6680 beg = sym + 1;
4d6ed7c8 6681 }
1b31d05e 6682
4d6ed7c8
NC		 6683 if (best)
6684 {
57346661 6685 *symname = (best->st_name >= strtab_size
2b692964 6686 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6687 *offset = dist;
6688 return;
6689 }
1b31d05e 6690
4d6ed7c8
NC		 6691 *symname = NULL;
6692 *offset = addr.offset;
6693}
6694
948f632f
DA		 6695static int
6696symcmp (const void *p, const void *q)
6697{
6698 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6699 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6700
6701 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6702}
6703
6704/* Process the unwind section. */
6705
6706#include "unwind-ia64.h"
6707
6708struct ia64_unw_table_entry
6709{
6710 struct absaddr start;
6711 struct absaddr end;
6712 struct absaddr info;
6713};
6714
6715struct ia64_unw_aux_info
6716{
6717 struct ia64_unw_table_entry *table; /* Unwind table. */
6718 unsigned long table_len; /* Length of unwind table. */
6719 unsigned char * info; /* Unwind info. */
6720 unsigned long info_size; /* Size of unwind info. */
6721 bfd_vma info_addr; /* Starting address of unwind info. */
6722 bfd_vma seg_base; /* Starting address of segment. */
6723 Elf_Internal_Sym * symtab; /* The symbol table. */
6724 unsigned long nsyms; /* Number of symbols. */
6725 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6726 unsigned long nfuns; /* Number of entries in funtab. */
6727 char * strtab; /* The string table. */
6728 unsigned long strtab_size; /* Size of string table. */
6729};
6730
4d6ed7c8 6731static void
2cf0635d 6732dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6733{
2cf0635d 6734 struct ia64_unw_table_entry * tp;
948f632f 6735 unsigned long j, nfuns;
4d6ed7c8 6736 int in_body;
7036c0e1 6737
948f632f
DA		 6738 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6739 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6740 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6741 aux->funtab[nfuns++] = aux->symtab[j];
6742 aux->nfuns = nfuns;
6743 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6744
4d6ed7c8
NC		 6745 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6746 {
6747 bfd_vma stamp;
6748 bfd_vma offset;
2cf0635d
NC		 6749 const unsigned char * dp;
6750 const unsigned char * head;
53774b7e 6751 const unsigned char * end;
2cf0635d 6752 const char * procname;
4d6ed7c8 6753
948f632f 6754 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6755 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6756
6757 fputs ("\n<", stdout);
6758
6759 if (procname)
6760 {
6761 fputs (procname, stdout);
6762
6763 if (offset)
6764 printf ("+%lx", (unsigned long) offset);
6765 }
6766
6767 fputs (">: [", stdout);
6768 print_vma (tp->start.offset, PREFIX_HEX);
6769 fputc ('-', stdout);
6770 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6771 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6772 (unsigned long) (tp->info.offset - aux->seg_base));
6773
53774b7e
NC		 6774 /* PR 17531: file: 86232b32. */
6775 if (aux->info == NULL)
6776 continue;
6777
6778 /* PR 17531: file: 0997b4d1. */
6779 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6780 {
6781 warn (_("Invalid offset %lx in table entry %ld\n"),
6782 (long) tp->info.offset, (long) (tp - aux->table));
6783 continue;
6784 }
6785
1949de15 6786 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6787 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6788
86f55779 6789 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6790 (unsigned) UNW_VER (stamp),
6791 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6792 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6793 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6794 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6795
6796 if (UNW_VER (stamp) != 1)
6797 {
2b692964 6798 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6799 continue;
6800 }
6801
6802 in_body = 0;
53774b7e
NC		 6803 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6804 /* PR 17531: file: 16ceda89. */
6805 if (end > aux->info + aux->info_size)
6806 end = aux->info + aux->info_size;
6807 for (dp = head + 8; dp < end;)
b4477bc8 6808 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6809 }
948f632f
DA		 6810
6811 free (aux->funtab);
4d6ed7c8
NC		 6812}
6813
53774b7e 6814static bfd_boolean
2cf0635d
NC		 6815slurp_ia64_unwind_table (FILE * file,
6816 struct ia64_unw_aux_info * aux,
6817 Elf_Internal_Shdr * sec)
4d6ed7c8 6818{
89fac5e3 6819 unsigned long size, nrelas, i;
2cf0635d
NC		 6820 Elf_Internal_Phdr * seg;
6821 struct ia64_unw_table_entry * tep;
6822 Elf_Internal_Shdr * relsec;
6823 Elf_Internal_Rela * rela;
6824 Elf_Internal_Rela * rp;
6825 unsigned char * table;
6826 unsigned char * tp;
6827 Elf_Internal_Sym * sym;
6828 const char * relname;
4d6ed7c8 6829
53774b7e
NC		 6830 aux->table_len = 0;
6831
4d6ed7c8
NC		 6832 /* First, find the starting address of the segment that includes
6833 this section: */
6834
6835 if (elf_header.e_phnum)
6836 {
d93f0186 6837 if (! get_program_headers (file))
53774b7e 6838 return FALSE;
4d6ed7c8 6839
d93f0186
NC		 6840 for (seg = program_headers;
6841 seg < program_headers + elf_header.e_phnum;
6842 ++seg)
4d6ed7c8
NC		 6843 {
6844 if (seg->p_type != PT_LOAD)
6845 continue;
6846
6847 if (sec->sh_addr >= seg->p_vaddr
6848 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6849 {
6850 aux->seg_base = seg->p_vaddr;
6851 break;
6852 }
6853 }
4d6ed7c8
NC		 6854 }
6855
6856 /* Second, build the unwind table from the contents of the unwind section: */
6857 size = sec->sh_size;
3f5e193b
NC		 6858 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6859 _("unwind table"));
a6e9f9df 6860 if (!table)
53774b7e 6861 return FALSE;
4d6ed7c8 6862
53774b7e 6863 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6864 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6865 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6866 tep = aux->table;
53774b7e
NC		 6867
6868 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6869 {
6870 tep->start.section = SHN_UNDEF;
6871 tep->end.section = SHN_UNDEF;
6872 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6873 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6874 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6875 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6876 tep->start.offset += aux->seg_base;
6877 tep->end.offset += aux->seg_base;
6878 tep->info.offset += aux->seg_base;
6879 }
6880 free (table);
6881
41e92641 6882 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 6883 for (relsec = section_headers;
6884 relsec < section_headers + elf_header.e_shnum;
6885 ++relsec)
6886 {
6887 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 6888 || relsec->sh_info >= elf_header.e_shnum
6889 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 6890 continue;
6891
6892 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6893 & rela, & nrelas))
53774b7e
NC		 6894 {
6895 free (aux->table);
6896 aux->table = NULL;
6897 aux->table_len = 0;
6898 return FALSE;
6899 }
4d6ed7c8
NC		 6900
6901 for (rp = rela; rp < rela + nrelas; ++rp)
6902 {
aca88567
NC		 6903 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6904 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 6905
82b1b41b
NC		 6906 /* PR 17531: file: 9fa67536. */
6907 if (relname == NULL)
6908 {
6909 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6910 continue;
6911 }
948f632f 6912
0112cd26 6913 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 6914 {
82b1b41b 6915 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 6916 continue;
6917 }
6918
89fac5e3 6919 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 6920
53774b7e
NC		 6921 /* PR 17531: file: 5bc8d9bf. */
6922 if (i >= aux->table_len)
6923 {
6924 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6925 continue;
6926 }
6927
6928 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 6929 {
6930 case 0:
6931 aux->table[i].start.section = sym->st_shndx;
e466bc6e 6932 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6933 break;
6934 case 1:
6935 aux->table[i].end.section = sym->st_shndx;
e466bc6e 6936 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6937 break;
6938 case 2:
6939 aux->table[i].info.section = sym->st_shndx;
e466bc6e 6940 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 6941 break;
6942 default:
6943 break;
6944 }
6945 }
6946
6947 free (rela);
6948 }
6949
53774b7e 6950 return TRUE;
4d6ed7c8
NC		 6951}
6952
1b31d05e 6953static void
2cf0635d 6954ia64_process_unwind (FILE * file)
4d6ed7c8 6955{
2cf0635d
NC		 6956 Elf_Internal_Shdr * sec;
6957 Elf_Internal_Shdr * unwsec = NULL;
6958 Elf_Internal_Shdr * strsec;
89fac5e3 6959 unsigned long i, unwcount = 0, unwstart = 0;
57346661 6960 struct ia64_unw_aux_info aux;
f1467e33 6961
4d6ed7c8
NC		 6962 memset (& aux, 0, sizeof (aux));
6963
4d6ed7c8
NC		 6964 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6965 {
c256ffe7 6966 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 6967 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 6968 {
ba5cdace 6969 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 6970
4fbb74a6 6971 strsec = section_headers + sec->sh_link;
4082ef84
NC		 6972 if (aux.strtab != NULL)
6973 {
6974 error (_("Multiple auxillary string tables encountered\n"));
6975 free (aux.strtab);
6976 }
3f5e193b
NC		 6977 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6978 1, strsec->sh_size,
6979 _("string table"));
c256ffe7 6980 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 6981 }
6982 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 6983 unwcount++;
6984 }
6985
6986 if (!unwcount)
6987 printf (_("\nThere are no unwind sections in this file.\n"));
6988
6989 while (unwcount-- > 0)
6990 {
2cf0635d 6991 char * suffix;
579f31ac
JJ		 6992 size_t len, len2;
6993
4082ef84 6994 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 6995 i < elf_header.e_shnum; ++i, ++sec)
6996 if (sec->sh_type == SHT_IA_64_UNWIND)
6997 {
6998 unwsec = sec;
6999 break;
7000 }
4082ef84
NC		 7001 /* We have already counted the number of SHT_IA64_UNWIND
7002 sections so the loop above should never fail. */
7003 assert (unwsec != NULL);
579f31ac
JJ		 7004
7005 unwstart = i + 1;
7006 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7007
e4b17d5c
L		 7008 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7009 {
7010 /* We need to find which section group it is in. */
4082ef84 7011 struct group_list * g;
e4b17d5c 7012
4082ef84
NC		 7013 if (section_headers_groups == NULL
7014 || section_headers_groups [i] == NULL)
7015 i = elf_header.e_shnum;
7016 else
e4b17d5c 7017 {
4082ef84 7018 g = section_headers_groups [i]->root;
18bd398b 7019
4082ef84
NC		 7020 for (; g != NULL; g = g->next)
7021 {
7022 sec = section_headers + g->section_index;
e4b17d5c 7023
4082ef84
NC		 7024 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7025 break;
7026 }
7027
7028 if (g == NULL)
7029 i = elf_header.e_shnum;
7030 }
e4b17d5c 7031 }
18bd398b 7032 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7033 {
18bd398b 7034 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7035 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7036 suffix = SECTION_NAME (unwsec) + len;
7037 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7038 ++i, ++sec)
18bd398b
NC		 7039 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7040 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7041 break;
7042 }
7043 else
7044 {
7045 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7046 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7047 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7048 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7049 suffix = "";
18bd398b 7050 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7051 suffix = SECTION_NAME (unwsec) + len;
7052 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7053 ++i, ++sec)
18bd398b
NC		 7054 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7055 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7056 break;
7057 }
7058
7059 if (i == elf_header.e_shnum)
7060 {
7061 printf (_("\nCould not find unwind info section for "));
7062
7063 if (string_table == NULL)
7064 printf ("%d", unwsec->sh_name);
7065 else
74e1a04b 7066 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7067 }
7068 else
4d6ed7c8 7069 {
4d6ed7c8 7070 aux.info_addr = sec->sh_addr;
3f5e193b 7071 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7072 sec->sh_size,
7073 _("unwind info"));
59245841 7074 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7075
579f31ac 7076 printf (_("\nUnwind section "));
4d6ed7c8 7077
579f31ac
JJ		 7078 if (string_table == NULL)
7079 printf ("%d", unwsec->sh_name);
7080 else
74e1a04b 7081 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7082
579f31ac 7083 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7084 (unsigned long) unwsec->sh_offset,
89fac5e3 7085 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7086
53774b7e
NC		 7087 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7088 && aux.table_len > 0)
579f31ac
JJ		 7089 dump_ia64_unwind (& aux);
7090
7091 if (aux.table)
7092 free ((char *) aux.table);
7093 if (aux.info)
7094 free ((char *) aux.info);
7095 aux.table = NULL;
7096 aux.info = NULL;
7097 }
4d6ed7c8 7098 }
4d6ed7c8 7099
4d6ed7c8
NC		 7100 if (aux.symtab)
7101 free (aux.symtab);
7102 if (aux.strtab)
7103 free ((char *) aux.strtab);
4d6ed7c8
NC		 7104}
7105
3f5e193b
NC		 7106struct hppa_unw_table_entry
7107 {
7108 struct absaddr start;
7109 struct absaddr end;
948f632f 7110 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7111 unsigned int Millicode:1; /* 1 */
7112 unsigned int Millicode_save_sr0:1; /* 2 */
7113 unsigned int Region_description:2; /* 3..4 */
7114 unsigned int reserved1:1; /* 5 */
7115 unsigned int Entry_SR:1; /* 6 */
7116 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7117 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7118 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7119 unsigned int Variable_Frame:1; /* 17 */
7120 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7121 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7122 unsigned int Stack_Overflow_Check:1; /* 20 */
7123 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7124 unsigned int Ada_Region:1; /* 22 */
7125 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7126 unsigned int cxx_try_catch:1; /* 24 */
7127 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7128 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7129 unsigned int Save_SP:1; /* 27 */
7130 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7131 unsigned int Save_MRP_in_frame:1; /* 29 */
7132 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7133 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7134
948f632f
DA		 7135 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7136 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7137 unsigned int Large_frame:1; /* 2 */
948f632f 7138 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7139 unsigned int reserved4:1; /* 4 */
7140 unsigned int Total_frame_size:27; /* 5..31 */
7141 };
7142
57346661 7143struct hppa_unw_aux_info
948f632f
DA		 7144{
7145 struct hppa_unw_table_entry * table; /* Unwind table. */
7146 unsigned long table_len; /* Length of unwind table. */
7147 bfd_vma seg_base; /* Starting address of segment. */
7148 Elf_Internal_Sym * symtab; /* The symbol table. */
7149 unsigned long nsyms; /* Number of symbols. */
7150 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7151 unsigned long nfuns; /* Number of entries in funtab. */
7152 char * strtab; /* The string table. */
7153 unsigned long strtab_size; /* Size of string table. */
7154};
57346661
AM		 7155
7156static void
2cf0635d 7157dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7158{
2cf0635d 7159 struct hppa_unw_table_entry * tp;
948f632f
DA		 7160 unsigned long j, nfuns;
7161
7162 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7163 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7164 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7165 aux->funtab[nfuns++] = aux->symtab[j];
7166 aux->nfuns = nfuns;
7167 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7168
57346661
AM		 7169 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7170 {
7171 bfd_vma offset;
2cf0635d 7172 const char * procname;
57346661 7173
948f632f 7174 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7175 aux->strtab_size, tp->start, &procname,
7176 &offset);
7177
7178 fputs ("\n<", stdout);
7179
7180 if (procname)
7181 {
7182 fputs (procname, stdout);
7183
7184 if (offset)
7185 printf ("+%lx", (unsigned long) offset);
7186 }
7187
7188 fputs (">: [", stdout);
7189 print_vma (tp->start.offset, PREFIX_HEX);
7190 fputc ('-', stdout);
7191 print_vma (tp->end.offset, PREFIX_HEX);
7192 printf ("]\n\t");
7193
18bd398b
NC		 7194#define PF(_m) if (tp->_m) printf (#_m " ");
7195#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7196 PF(Cannot_unwind);
7197 PF(Millicode);
7198 PF(Millicode_save_sr0);
18bd398b 7199 /* PV(Region_description); */
57346661
AM		 7200 PF(Entry_SR);
7201 PV(Entry_FR);
7202 PV(Entry_GR);
7203 PF(Args_stored);
7204 PF(Variable_Frame);
7205 PF(Separate_Package_Body);
7206 PF(Frame_Extension_Millicode);
7207 PF(Stack_Overflow_Check);
7208 PF(Two_Instruction_SP_Increment);
7209 PF(Ada_Region);
7210 PF(cxx_info);
7211 PF(cxx_try_catch);
7212 PF(sched_entry_seq);
7213 PF(Save_SP);
7214 PF(Save_RP);
7215 PF(Save_MRP_in_frame);
7216 PF(extn_ptr_defined);
7217 PF(Cleanup_defined);
7218 PF(MPE_XL_interrupt_marker);
7219 PF(HP_UX_interrupt_marker);
7220 PF(Large_frame);
7221 PF(Pseudo_SP_Set);
7222 PV(Total_frame_size);
7223#undef PF
7224#undef PV
7225 }
7226
18bd398b 7227 printf ("\n");
948f632f
DA		 7228
7229 free (aux->funtab);
57346661
AM		 7230}
7231
7232static int
2cf0635d
NC		 7233slurp_hppa_unwind_table (FILE * file,
7234 struct hppa_unw_aux_info * aux,
7235 Elf_Internal_Shdr * sec)
57346661 7236{
1c0751b2 7237 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7238 Elf_Internal_Phdr * seg;
7239 struct hppa_unw_table_entry * tep;
7240 Elf_Internal_Shdr * relsec;
7241 Elf_Internal_Rela * rela;
7242 Elf_Internal_Rela * rp;
7243 unsigned char * table;
7244 unsigned char * tp;
7245 Elf_Internal_Sym * sym;
7246 const char * relname;
57346661 7247
57346661
AM		 7248 /* First, find the starting address of the segment that includes
7249 this section. */
7250
7251 if (elf_header.e_phnum)
7252 {
7253 if (! get_program_headers (file))
7254 return 0;
7255
7256 for (seg = program_headers;
7257 seg < program_headers + elf_header.e_phnum;
7258 ++seg)
7259 {
7260 if (seg->p_type != PT_LOAD)
7261 continue;
7262
7263 if (sec->sh_addr >= seg->p_vaddr
7264 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7265 {
7266 aux->seg_base = seg->p_vaddr;
7267 break;
7268 }
7269 }
7270 }
7271
7272 /* Second, build the unwind table from the contents of the unwind
7273 section. */
7274 size = sec->sh_size;
3f5e193b
NC		 7275 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7276 _("unwind table"));
57346661
AM		 7277 if (!table)
7278 return 0;
7279
1c0751b2
DA		 7280 unw_ent_size = 16;
7281 nentries = size / unw_ent_size;
7282 size = unw_ent_size * nentries;
57346661 7283
3f5e193b
NC		 7284 tep = aux->table = (struct hppa_unw_table_entry *)
7285 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7286
1c0751b2 7287 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7288 {
7289 unsigned int tmp1, tmp2;
7290
7291 tep->start.section = SHN_UNDEF;
7292 tep->end.section = SHN_UNDEF;
7293
1c0751b2
DA		 7294 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7295 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7296 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7297 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7298
7299 tep->start.offset += aux->seg_base;
7300 tep->end.offset += aux->seg_base;
57346661
AM		 7301
7302 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7303 tep->Millicode = (tmp1 >> 30) & 0x1;
7304 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7305 tep->Region_description = (tmp1 >> 27) & 0x3;
7306 tep->reserved1 = (tmp1 >> 26) & 0x1;
7307 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7308 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7309 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7310 tep->Args_stored = (tmp1 >> 15) & 0x1;
7311 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7312 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7313 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7314 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7315 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7316 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7317 tep->cxx_info = (tmp1 >> 8) & 0x1;
7318 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7319 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7320 tep->reserved2 = (tmp1 >> 5) & 0x1;
7321 tep->Save_SP = (tmp1 >> 4) & 0x1;
7322 tep->Save_RP = (tmp1 >> 3) & 0x1;
7323 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7324 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7325 tep->Cleanup_defined = tmp1 & 0x1;
7326
7327 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7328 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7329 tep->Large_frame = (tmp2 >> 29) & 0x1;
7330 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7331 tep->reserved4 = (tmp2 >> 27) & 0x1;
7332 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7333 }
7334 free (table);
7335
7336 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7337 for (relsec = section_headers;
7338 relsec < section_headers + elf_header.e_shnum;
7339 ++relsec)
7340 {
7341 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7342 || relsec->sh_info >= elf_header.e_shnum
7343 || section_headers + relsec->sh_info != sec)
57346661
AM		 7344 continue;
7345
7346 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7347 & rela, & nrelas))
7348 return 0;
7349
7350 for (rp = rela; rp < rela + nrelas; ++rp)
7351 {
aca88567
NC		 7352 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7353 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7354
7355 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7356 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7357 {
7358 warn (_("Skipping unexpected relocation type %s\n"), relname);
7359 continue;
7360 }
7361
7362 i = rp->r_offset / unw_ent_size;
7363
89fac5e3 7364 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7365 {
7366 case 0:
7367 aux->table[i].start.section = sym->st_shndx;
1e456d54 7368 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7369 break;
7370 case 1:
7371 aux->table[i].end.section = sym->st_shndx;
1e456d54 7372 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7373 break;
7374 default:
7375 break;
7376 }
7377 }
7378
7379 free (rela);
7380 }
7381
1c0751b2 7382 aux->table_len = nentries;
57346661
AM		 7383
7384 return 1;
7385}
7386
1b31d05e 7387static void
2cf0635d 7388hppa_process_unwind (FILE * file)
57346661 7389{
57346661 7390 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7391 Elf_Internal_Shdr * unwsec = NULL;
7392 Elf_Internal_Shdr * strsec;
7393 Elf_Internal_Shdr * sec;
18bd398b 7394 unsigned long i;
57346661 7395
c256ffe7 7396 if (string_table == NULL)
1b31d05e
NC		 7397 return;
7398
7399 memset (& aux, 0, sizeof (aux));
57346661
AM		 7400
7401 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7402 {
c256ffe7 7403 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7404 && sec->sh_link < elf_header.e_shnum)
57346661 7405 {
ba5cdace 7406 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7407
4fbb74a6 7408 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7409 if (aux.strtab != NULL)
7410 {
7411 error (_("Multiple auxillary string tables encountered\n"));
7412 free (aux.strtab);
7413 }
3f5e193b
NC		 7414 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7415 1, strsec->sh_size,
7416 _("string table"));
c256ffe7 7417 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7418 }
18bd398b 7419 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7420 unwsec = sec;
7421 }
7422
7423 if (!unwsec)
7424 printf (_("\nThere are no unwind sections in this file.\n"));
7425
7426 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7427 {
18bd398b 7428 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7429 {
74e1a04b
NC		 7430 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7431 printable_section_name (sec),
57346661 7432 (unsigned long) sec->sh_offset,
89fac5e3 7433 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7434
7435 slurp_hppa_unwind_table (file, &aux, sec);
7436 if (aux.table_len > 0)
7437 dump_hppa_unwind (&aux);
7438
7439 if (aux.table)
7440 free ((char *) aux.table);
7441 aux.table = NULL;
7442 }
7443 }
7444
7445 if (aux.symtab)
7446 free (aux.symtab);
7447 if (aux.strtab)
7448 free ((char *) aux.strtab);
57346661
AM		 7449}
7450
0b6ae522
DJ		 7451struct arm_section
7452{
a734115a
NC		 7453 unsigned char * data; /* The unwind data. */
7454 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7455 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7456 unsigned long nrelas; /* The number of relocations. */
7457 unsigned int rel_type; /* REL or RELA ? */
7458 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7459};
7460
7461struct arm_unw_aux_info
7462{
a734115a
NC		 7463 FILE * file; /* The file containing the unwind sections. */
7464 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7465 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7466 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7467 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7468 char * strtab; /* The file's string table. */
7469 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7470};
7471
7472static const char *
7473arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7474 bfd_vma fn, struct absaddr addr)
7475{
7476 const char *procname;
7477 bfd_vma sym_offset;
7478
7479 if (addr.section == SHN_UNDEF)
7480 addr.offset = fn;
7481
948f632f 7482 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7483 aux->strtab_size, addr, &procname,
7484 &sym_offset);
7485
7486 print_vma (fn, PREFIX_HEX);
7487
7488 if (procname)
7489 {
7490 fputs (" <", stdout);
7491 fputs (procname, stdout);
7492
7493 if (sym_offset)
7494 printf ("+0x%lx", (unsigned long) sym_offset);
7495 fputc ('>', stdout);
7496 }
7497
7498 return procname;
7499}
7500
7501static void
7502arm_free_section (struct arm_section *arm_sec)
7503{
7504 if (arm_sec->data != NULL)
7505 free (arm_sec->data);
7506
7507 if (arm_sec->rela != NULL)
7508 free (arm_sec->rela);
7509}
7510
a734115a
NC		 7511/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7512 cached section and install SEC instead.
7513 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7514 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7515 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7516 relocation's offset in ADDR.
1b31d05e
NC		 7517 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7518 into the string table of the symbol associated with the reloc. If no
7519 reloc was applied store -1 there.
7520 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7521
7522static bfd_boolean
1b31d05e
NC		 7523get_unwind_section_word (struct arm_unw_aux_info * aux,
7524 struct arm_section * arm_sec,
7525 Elf_Internal_Shdr * sec,
7526 bfd_vma word_offset,
7527 unsigned int * wordp,
7528 struct absaddr * addr,
7529 bfd_vma * sym_name)
0b6ae522
DJ		 7530{
7531 Elf_Internal_Rela *rp;
7532 Elf_Internal_Sym *sym;
7533 const char * relname;
7534 unsigned int word;
7535 bfd_boolean wrapped;
7536
e0a31db1
NC		 7537 if (sec == NULL || arm_sec == NULL)
7538 return FALSE;
7539
0b6ae522
DJ		 7540 addr->section = SHN_UNDEF;
7541 addr->offset = 0;
7542
1b31d05e
NC		 7543 if (sym_name != NULL)
7544 *sym_name = (bfd_vma) -1;
7545
a734115a 7546 /* If necessary, update the section cache. */
0b6ae522
DJ		 7547 if (sec != arm_sec->sec)
7548 {
7549 Elf_Internal_Shdr *relsec;
7550
7551 arm_free_section (arm_sec);
7552
7553 arm_sec->sec = sec;
7554 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7555 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7556 arm_sec->rela = NULL;
7557 arm_sec->nrelas = 0;
7558
7559 for (relsec = section_headers;
7560 relsec < section_headers + elf_header.e_shnum;
7561 ++relsec)
7562 {
7563 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7564 || section_headers + relsec->sh_info != sec
7565 /* PR 15745: Check the section type as well. */
7566 || (relsec->sh_type != SHT_REL
7567 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7568 continue;
7569
a734115a 7570 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7571 if (relsec->sh_type == SHT_REL)
7572 {
7573 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7574 relsec->sh_size,
7575 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7576 return FALSE;
0b6ae522 7577 }
1ae40aa4 7578 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7579 {
7580 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7581 relsec->sh_size,
7582 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7583 return FALSE;
0b6ae522 7584 }
1ae40aa4 7585 break;
0b6ae522
DJ		 7586 }
7587
7588 arm_sec->next_rela = arm_sec->rela;
7589 }
7590
a734115a 7591 /* If there is no unwind data we can do nothing. */
0b6ae522 7592 if (arm_sec->data == NULL)
a734115a 7593 return FALSE;
0b6ae522 7594
e0a31db1 7595 /* If the offset is invalid then fail. */
1a915552
NC		 7596 if (word_offset > (sec->sh_size - 4)
7597 /* PR 18879 */
7598 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7599 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7600 return FALSE;
7601
a734115a 7602 /* Get the word at the required offset. */
0b6ae522
DJ		 7603 word = byte_get (arm_sec->data + word_offset, 4);
7604
0eff7165
NC		 7605 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7606 if (arm_sec->rela == NULL)
7607 {
7608 * wordp = word;
7609 return TRUE;
7610 }
7611
a734115a 7612 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7613 wrapped = FALSE;
7614 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7615 {
7616 bfd_vma prelval, offset;
7617
7618 if (rp->r_offset > word_offset && !wrapped)
7619 {
7620 rp = arm_sec->rela;
7621 wrapped = TRUE;
7622 }
7623 if (rp->r_offset > word_offset)
7624 break;
7625
7626 if (rp->r_offset & 3)
7627 {
7628 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7629 (unsigned long) rp->r_offset);
7630 continue;
7631 }
7632
7633 if (rp->r_offset < word_offset)
7634 continue;
7635
74e1a04b
NC		 7636 /* PR 17531: file: 027-161405-0.004 */
7637 if (aux->symtab == NULL)
7638 continue;
7639
0b6ae522
DJ		 7640 if (arm_sec->rel_type == SHT_REL)
7641 {
7642 offset = word & 0x7fffffff;
7643 if (offset & 0x40000000)
7644 offset |= ~ (bfd_vma) 0x7fffffff;
7645 }
a734115a 7646 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7647 offset = rp->r_addend;
a734115a 7648 else
74e1a04b
NC		 7649 {
7650 error (_("Unknown section relocation type %d encountered\n"),
7651 arm_sec->rel_type);
7652 break;
7653 }
0b6ae522 7654
071436c6
NC		 7655 /* PR 17531 file: 027-1241568-0.004. */
7656 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7657 {
7658 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7659 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7660 break;
7661 }
7662
7663 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7664 offset += sym->st_value;
7665 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7666
a734115a
NC		 7667 /* Check that we are processing the expected reloc type. */
7668 if (elf_header.e_machine == EM_ARM)
7669 {
7670 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7671 if (relname == NULL)
7672 {
7673 warn (_("Skipping unknown ARM relocation type: %d\n"),
7674 (int) ELF32_R_TYPE (rp->r_info));
7675 continue;
7676 }
a734115a
NC		 7677
7678 if (streq (relname, "R_ARM_NONE"))
7679 continue;
0b4362b0 7680
a734115a
NC		 7681 if (! streq (relname, "R_ARM_PREL31"))
7682 {
071436c6 7683 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7684 continue;
7685 }
7686 }
7687 else if (elf_header.e_machine == EM_TI_C6000)
7688 {
7689 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7690 if (relname == NULL)
7691 {
7692 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7693 (int) ELF32_R_TYPE (rp->r_info));
7694 continue;
7695 }
0b4362b0 7696
a734115a
NC		 7697 if (streq (relname, "R_C6000_NONE"))
7698 continue;
7699
7700 if (! streq (relname, "R_C6000_PREL31"))
7701 {
071436c6 7702 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7703 continue;
7704 }
7705
7706 prelval >>= 1;
7707 }
7708 else
74e1a04b
NC		 7709 {
7710 /* This function currently only supports ARM and TI unwinders. */
7711 warn (_("Only TI and ARM unwinders are currently supported\n"));
7712 break;
7713 }
fa197c1c 7714
0b6ae522
DJ		 7715 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7716 addr->section = sym->st_shndx;
7717 addr->offset = offset;
74e1a04b 7718
1b31d05e
NC		 7719 if (sym_name)
7720 * sym_name = sym->st_name;
0b6ae522
DJ		 7721 break;
7722 }
7723
7724 *wordp = word;
7725 arm_sec->next_rela = rp;
7726
a734115a 7727 return TRUE;
0b6ae522
DJ		 7728}
7729
a734115a
NC		 7730static const char *tic6x_unwind_regnames[16] =
7731{
0b4362b0
RM		 7732 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7733 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7734 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7735};
fa197c1c 7736
0b6ae522 7737static void
fa197c1c 7738decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7739{
fa197c1c
PB		 7740 int i;
7741
7742 for (i = 12; mask; mask >>= 1, i--)
7743 {
7744 if (mask & 1)
7745 {
7746 fputs (tic6x_unwind_regnames[i], stdout);
7747 if (mask > 1)
7748 fputs (", ", stdout);
7749 }
7750 }
7751}
0b6ae522
DJ		 7752
7753#define ADVANCE \
7754 if (remaining == 0 && more_words) \
7755 { \
7756 data_offset += 4; \
1b31d05e
NC		 7757 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7758 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7759 return; \
7760 remaining = 4; \
7761 more_words--; \
7762 } \
7763
7764#define GET_OP(OP) \
7765 ADVANCE; \
7766 if (remaining) \
7767 { \
7768 remaining--; \
7769 (OP) = word >> 24; \
7770 word <<= 8; \
7771 } \
7772 else \
7773 { \
2b692964 7774 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7775 return; \
7776 } \
cc5914eb 7777 printf ("0x%02x ", OP)
0b6ae522 7778
fa197c1c 7779static void
948f632f
DA		 7780decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7781 unsigned int word,
7782 unsigned int remaining,
7783 unsigned int more_words,
7784 bfd_vma data_offset,
7785 Elf_Internal_Shdr * data_sec,
7786 struct arm_section * data_arm_sec)
fa197c1c
PB		 7787{
7788 struct absaddr addr;
0b6ae522
DJ		 7789
7790 /* Decode the unwinding instructions. */
7791 while (1)
7792 {
7793 unsigned int op, op2;
7794
7795 ADVANCE;
7796 if (remaining == 0)
7797 break;
7798 remaining--;
7799 op = word >> 24;
7800 word <<= 8;
7801
cc5914eb 7802 printf (" 0x%02x ", op);
0b6ae522
DJ		 7803
7804 if ((op & 0xc0) == 0x00)
7805 {
7806 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7807
cc5914eb 7808 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7809 }
7810 else if ((op & 0xc0) == 0x40)
7811 {
7812 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7813
cc5914eb 7814 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7815 }
7816 else if ((op & 0xf0) == 0x80)
7817 {
7818 GET_OP (op2);
7819 if (op == 0x80 && op2 == 0)
7820 printf (_("Refuse to unwind"));
7821 else
7822 {
7823 unsigned int mask = ((op & 0x0f) << 8) | op2;
7824 int first = 1;
7825 int i;
2b692964 7826
0b6ae522
DJ		 7827 printf ("pop {");
7828 for (i = 0; i < 12; i++)
7829 if (mask & (1 << i))
7830 {
7831 if (first)
7832 first = 0;
7833 else
7834 printf (", ");
7835 printf ("r%d", 4 + i);
7836 }
7837 printf ("}");
7838 }
7839 }
7840 else if ((op & 0xf0) == 0x90)
7841 {
7842 if (op == 0x9d || op == 0x9f)
7843 printf (_(" [Reserved]"));
7844 else
cc5914eb 7845 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7846 }
7847 else if ((op & 0xf0) == 0xa0)
7848 {
7849 int end = 4 + (op & 0x07);
7850 int first = 1;
7851 int i;
61865e30 7852
0b6ae522
DJ		 7853 printf (" pop {");
7854 for (i = 4; i <= end; i++)
7855 {
7856 if (first)
7857 first = 0;
7858 else
7859 printf (", ");
7860 printf ("r%d", i);
7861 }
7862 if (op & 0x08)
7863 {
1b31d05e 7864 if (!first)
0b6ae522
DJ		 7865 printf (", ");
7866 printf ("r14");
7867 }
7868 printf ("}");
7869 }
7870 else if (op == 0xb0)
7871 printf (_(" finish"));
7872 else if (op == 0xb1)
7873 {
7874 GET_OP (op2);
7875 if (op2 == 0 || (op2 & 0xf0) != 0)
7876 printf (_("[Spare]"));
7877 else
7878 {
7879 unsigned int mask = op2 & 0x0f;
7880 int first = 1;
7881 int i;
61865e30 7882
0b6ae522
DJ		 7883 printf ("pop {");
7884 for (i = 0; i < 12; i++)
7885 if (mask & (1 << i))
7886 {
7887 if (first)
7888 first = 0;
7889 else
7890 printf (", ");
7891 printf ("r%d", i);
7892 }
7893 printf ("}");
7894 }
7895 }
7896 else if (op == 0xb2)
7897 {
b115cf96 7898 unsigned char buf[9];
0b6ae522
DJ		 7899 unsigned int i, len;
7900 unsigned long offset;
61865e30 7901
b115cf96 7902 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 7903 {
7904 GET_OP (buf[i]);
7905 if ((buf[i] & 0x80) == 0)
7906 break;
7907 }
4082ef84
NC		 7908 if (i == sizeof (buf))
7909 printf (_("corrupt change to vsp"));
7910 else
7911 {
7912 offset = read_uleb128 (buf, &len, buf + i + 1);
7913 assert (len == i + 1);
7914 offset = offset * 4 + 0x204;
7915 printf ("vsp = vsp + %ld", offset);
7916 }
0b6ae522 7917 }
61865e30 7918 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 7919 {
61865e30
NC		 7920 unsigned int first, last;
7921
7922 GET_OP (op2);
7923 first = op2 >> 4;
7924 last = op2 & 0x0f;
7925 if (op == 0xc8)
7926 first = first + 16;
7927 printf ("pop {D%d", first);
7928 if (last)
7929 printf ("-D%d", first + last);
7930 printf ("}");
7931 }
7932 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7933 {
7934 unsigned int count = op & 0x07;
7935
7936 printf ("pop {D8");
7937 if (count)
7938 printf ("-D%d", 8 + count);
7939 printf ("}");
7940 }
7941 else if (op >= 0xc0 && op <= 0xc5)
7942 {
7943 unsigned int count = op & 0x07;
7944
7945 printf (" pop {wR10");
7946 if (count)
7947 printf ("-wR%d", 10 + count);
7948 printf ("}");
7949 }
7950 else if (op == 0xc6)
7951 {
7952 unsigned int first, last;
7953
7954 GET_OP (op2);
7955 first = op2 >> 4;
7956 last = op2 & 0x0f;
7957 printf ("pop {wR%d", first);
7958 if (last)
7959 printf ("-wR%d", first + last);
7960 printf ("}");
7961 }
7962 else if (op == 0xc7)
7963 {
7964 GET_OP (op2);
7965 if (op2 == 0 || (op2 & 0xf0) != 0)
7966 printf (_("[Spare]"));
0b6ae522
DJ		 7967 else
7968 {
61865e30
NC		 7969 unsigned int mask = op2 & 0x0f;
7970 int first = 1;
7971 int i;
7972
7973 printf ("pop {");
7974 for (i = 0; i < 4; i++)
7975 if (mask & (1 << i))
7976 {
7977 if (first)
7978 first = 0;
7979 else
7980 printf (", ");
7981 printf ("wCGR%d", i);
7982 }
7983 printf ("}");
0b6ae522
DJ		 7984 }
7985 }
61865e30
NC		 7986 else
7987 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 7988 printf ("\n");
7989 }
fa197c1c
PB		 7990}
7991
7992static void
948f632f
DA		 7993decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7994 unsigned int word,
7995 unsigned int remaining,
7996 unsigned int more_words,
7997 bfd_vma data_offset,
7998 Elf_Internal_Shdr * data_sec,
7999 struct arm_section * data_arm_sec)
fa197c1c
PB		 8000{
8001 struct absaddr addr;
8002
8003 /* Decode the unwinding instructions. */
8004 while (1)
8005 {
8006 unsigned int op, op2;
8007
8008 ADVANCE;
8009 if (remaining == 0)
8010 break;
8011 remaining--;
8012 op = word >> 24;
8013 word <<= 8;
8014
9cf03b7e 8015 printf (" 0x%02x ", op);
fa197c1c
PB		 8016
8017 if ((op & 0xc0) == 0x00)
8018 {
8019 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8020 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8021 }
8022 else if ((op & 0xc0) == 0x80)
8023 {
8024 GET_OP (op2);
8025 if (op == 0x80 && op2 == 0)
8026 printf (_("Refuse to unwind"));
8027 else
8028 {
8029 unsigned int mask = ((op & 0x1f) << 8) | op2;
8030 if (op & 0x20)
8031 printf ("pop compact {");
8032 else
8033 printf ("pop {");
8034
8035 decode_tic6x_unwind_regmask (mask);
8036 printf("}");
8037 }
8038 }
8039 else if ((op & 0xf0) == 0xc0)
8040 {
8041 unsigned int reg;
8042 unsigned int nregs;
8043 unsigned int i;
8044 const char *name;
a734115a
NC		 8045 struct
8046 {
fa197c1c
PB		 8047 unsigned int offset;
8048 unsigned int reg;
8049 } regpos[16];
8050
8051 /* Scan entire instruction first so that GET_OP output is not
8052 interleaved with disassembly. */
8053 nregs = 0;
8054 for (i = 0; nregs < (op & 0xf); i++)
8055 {
8056 GET_OP (op2);
8057 reg = op2 >> 4;
8058 if (reg != 0xf)
8059 {
8060 regpos[nregs].offset = i * 2;
8061 regpos[nregs].reg = reg;
8062 nregs++;
8063 }
8064
8065 reg = op2 & 0xf;
8066 if (reg != 0xf)
8067 {
8068 regpos[nregs].offset = i * 2 + 1;
8069 regpos[nregs].reg = reg;
8070 nregs++;
8071 }
8072 }
8073
8074 printf (_("pop frame {"));
8075 reg = nregs - 1;
8076 for (i = i * 2; i > 0; i--)
8077 {
8078 if (regpos[reg].offset == i - 1)
8079 {
8080 name = tic6x_unwind_regnames[regpos[reg].reg];
8081 if (reg > 0)
8082 reg--;
8083 }
8084 else
8085 name = _("[pad]");
8086
8087 fputs (name, stdout);
8088 if (i > 1)
8089 printf (", ");
8090 }
8091
8092 printf ("}");
8093 }
8094 else if (op == 0xd0)
8095 printf (" MOV FP, SP");
8096 else if (op == 0xd1)
8097 printf (" __c6xabi_pop_rts");
8098 else if (op == 0xd2)
8099 {
8100 unsigned char buf[9];
8101 unsigned int i, len;
8102 unsigned long offset;
a734115a 8103
fa197c1c
PB		 8104 for (i = 0; i < sizeof (buf); i++)
8105 {
8106 GET_OP (buf[i]);
8107 if ((buf[i] & 0x80) == 0)
8108 break;
8109 }
0eff7165
NC		 8110 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8111 if (i == sizeof (buf))
8112 {
8113 printf ("<corrupt sp adjust>\n");
8114 warn (_("Corrupt stack pointer adjustment detected\n"));
8115 return;
8116 }
948f632f 8117
f6f0e17b 8118 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8119 assert (len == i + 1);
8120 offset = offset * 8 + 0x408;
8121 printf (_("sp = sp + %ld"), offset);
8122 }
8123 else if ((op & 0xf0) == 0xe0)
8124 {
8125 if ((op & 0x0f) == 7)
8126 printf (" RETURN");
8127 else
8128 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8129 }
8130 else
8131 {
8132 printf (_(" [unsupported opcode]"));
8133 }
8134 putchar ('\n');
8135 }
8136}
8137
8138static bfd_vma
a734115a 8139arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8140{
8141 bfd_vma offset;
8142
8143 offset = word & 0x7fffffff;
8144 if (offset & 0x40000000)
8145 offset |= ~ (bfd_vma) 0x7fffffff;
8146
8147 if (elf_header.e_machine == EM_TI_C6000)
8148 offset <<= 1;
8149
8150 return offset + where;
8151}
8152
8153static void
1b31d05e
NC		 8154decode_arm_unwind (struct arm_unw_aux_info * aux,
8155 unsigned int word,
8156 unsigned int remaining,
8157 bfd_vma data_offset,
8158 Elf_Internal_Shdr * data_sec,
8159 struct arm_section * data_arm_sec)
fa197c1c
PB		 8160{
8161 int per_index;
8162 unsigned int more_words = 0;
37e14bc3 8163 struct absaddr addr;
1b31d05e 8164 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8165
8166 if (remaining == 0)
8167 {
1b31d05e
NC		 8168 /* Fetch the first word.
8169 Note - when decoding an object file the address extracted
8170 here will always be 0. So we also pass in the sym_name
8171 parameter so that we can find the symbol associated with
8172 the personality routine. */
8173 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8174 & word, & addr, & sym_name))
fa197c1c 8175 return;
1b31d05e 8176
fa197c1c
PB		 8177 remaining = 4;
8178 }
8179
8180 if ((word & 0x80000000) == 0)
8181 {
8182 /* Expand prel31 for personality routine. */
8183 bfd_vma fn;
8184 const char *procname;
8185
a734115a 8186 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8187 printf (_(" Personality routine: "));
1b31d05e
NC		 8188 if (fn == 0
8189 && addr.section == SHN_UNDEF && addr.offset == 0
8190 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8191 {
8192 procname = aux->strtab + sym_name;
8193 print_vma (fn, PREFIX_HEX);
8194 if (procname)
8195 {
8196 fputs (" <", stdout);
8197 fputs (procname, stdout);
8198 fputc ('>', stdout);
8199 }
8200 }
8201 else
8202 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8203 fputc ('\n', stdout);
8204
8205 /* The GCC personality routines use the standard compact
8206 encoding, starting with one byte giving the number of
8207 words. */
8208 if (procname != NULL
8209 && (const_strneq (procname, "__gcc_personality_v0")
8210 || const_strneq (procname, "__gxx_personality_v0")
8211 || const_strneq (procname, "__gcj_personality_v0")
8212 || const_strneq (procname, "__gnu_objc_personality_v0")))
8213 {
8214 remaining = 0;
8215 more_words = 1;
8216 ADVANCE;
8217 if (!remaining)
8218 {
8219 printf (_(" [Truncated data]\n"));
8220 return;
8221 }
8222 more_words = word >> 24;
8223 word <<= 8;
8224 remaining--;
8225 per_index = -1;
8226 }
8227 else
8228 return;
8229 }
8230 else
8231 {
1b31d05e 8232 /* ARM EHABI Section 6.3:
0b4362b0 8233
1b31d05e 8234 An exception-handling table entry for the compact model looks like:
0b4362b0 8235
1b31d05e
NC		 8236 31 30-28 27-24 23-0
8237 -- ----- ----- ----
8238 1 0 index Data for personalityRoutine[index] */
8239
8240 if (elf_header.e_machine == EM_ARM
8241 && (word & 0x70000000))
83c257ca 8242 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8243
fa197c1c 8244 per_index = (word >> 24) & 0x7f;
1b31d05e 8245 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8246 if (per_index == 0)
8247 {
8248 more_words = 0;
8249 word <<= 8;
8250 remaining--;
8251 }
8252 else if (per_index < 3)
8253 {
8254 more_words = (word >> 16) & 0xff;
8255 word <<= 16;
8256 remaining -= 2;
8257 }
8258 }
8259
8260 switch (elf_header.e_machine)
8261 {
8262 case EM_ARM:
8263 if (per_index < 3)
8264 {
8265 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8266 data_offset, data_sec, data_arm_sec);
8267 }
8268 else
1b31d05e
NC		 8269 {
8270 warn (_("Unknown ARM compact model index encountered\n"));
8271 printf (_(" [reserved]\n"));
8272 }
fa197c1c
PB		 8273 break;
8274
8275 case EM_TI_C6000:
8276 if (per_index < 3)
8277 {
8278 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8279 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8280 }
8281 else if (per_index < 5)
8282 {
8283 if (((word >> 17) & 0x7f) == 0x7f)
8284 printf (_(" Restore stack from frame pointer\n"));
8285 else
8286 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8287 printf (_(" Registers restored: "));
8288 if (per_index == 4)
8289 printf (" (compact) ");
8290 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8291 putchar ('\n');
8292 printf (_(" Return register: %s\n"),
8293 tic6x_unwind_regnames[word & 0xf]);
8294 }
8295 else
1b31d05e 8296 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8297 break;
8298
8299 default:
74e1a04b 8300 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8301 elf_header.e_machine);
fa197c1c 8302 }
0b6ae522
DJ		 8303
8304 /* Decode the descriptors. Not implemented. */
8305}
8306
8307static void
8308dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8309{
8310 struct arm_section exidx_arm_sec, extab_arm_sec;
8311 unsigned int i, exidx_len;
948f632f 8312 unsigned long j, nfuns;
0b6ae522
DJ		 8313
8314 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8315 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8316 exidx_len = exidx_sec->sh_size / 8;
8317
948f632f
DA		 8318 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8319 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8320 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8321 aux->funtab[nfuns++] = aux->symtab[j];
8322 aux->nfuns = nfuns;
8323 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8324
0b6ae522
DJ		 8325 for (i = 0; i < exidx_len; i++)
8326 {
8327 unsigned int exidx_fn, exidx_entry;
8328 struct absaddr fn_addr, entry_addr;
8329 bfd_vma fn;
8330
8331 fputc ('\n', stdout);
8332
1b31d05e
NC		 8333 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8334 8 * i, & exidx_fn, & fn_addr, NULL)
8335 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8336 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8337 {
948f632f 8338 free (aux->funtab);
1b31d05e
NC		 8339 arm_free_section (& exidx_arm_sec);
8340 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8341 return;
8342 }
8343
83c257ca
NC		 8344 /* ARM EHABI, Section 5:
8345 An index table entry consists of 2 words.
8346 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8347 if (exidx_fn & 0x80000000)
8348 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8349
a734115a 8350 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8351
a734115a 8352 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8353 fputs (": ", stdout);
8354
8355 if (exidx_entry == 1)
8356 {
8357 print_vma (exidx_entry, PREFIX_HEX);
8358 fputs (" [cantunwind]\n", stdout);
8359 }
8360 else if (exidx_entry & 0x80000000)
8361 {
8362 print_vma (exidx_entry, PREFIX_HEX);
8363 fputc ('\n', stdout);
8364 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8365 }
8366 else
8367 {
8f73510c 8368 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8369 Elf_Internal_Shdr *table_sec;
8370
8371 fputs ("@", stdout);
a734115a 8372 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8373 print_vma (table, PREFIX_HEX);
8374 printf ("\n");
8375
8376 /* Locate the matching .ARM.extab. */
8377 if (entry_addr.section != SHN_UNDEF
8378 && entry_addr.section < elf_header.e_shnum)
8379 {
8380 table_sec = section_headers + entry_addr.section;
8381 table_offset = entry_addr.offset;
1a915552
NC		 8382 /* PR 18879 */
8383 if (table_offset > table_sec->sh_size
8384 || ((bfd_signed_vma) table_offset) < 0)
8385 {
8386 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8387 (unsigned long) table_offset,
8388 printable_section_name (table_sec));
8389 continue;
8390 }
0b6ae522
DJ		 8391 }
8392 else
8393 {
8394 table_sec = find_section_by_address (table);
8395 if (table_sec != NULL)
8396 table_offset = table - table_sec->sh_addr;
8397 }
8398 if (table_sec == NULL)
8399 {
8400 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8401 (unsigned long) table);
8402 continue;
8403 }
8404 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8405 &extab_arm_sec);
8406 }
8407 }
8408
8409 printf ("\n");
8410
948f632f 8411 free (aux->funtab);
0b6ae522
DJ		 8412 arm_free_section (&exidx_arm_sec);
8413 arm_free_section (&extab_arm_sec);
8414}
8415
fa197c1c 8416/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8417
8418static void
0b6ae522
DJ		 8419arm_process_unwind (FILE *file)
8420{
8421 struct arm_unw_aux_info aux;
8422 Elf_Internal_Shdr *unwsec = NULL;
8423 Elf_Internal_Shdr *strsec;
8424 Elf_Internal_Shdr *sec;
8425 unsigned long i;
fa197c1c 8426 unsigned int sec_type;
0b6ae522 8427
fa197c1c
PB		 8428 switch (elf_header.e_machine)
8429 {
8430 case EM_ARM:
8431 sec_type = SHT_ARM_EXIDX;
8432 break;
8433
8434 case EM_TI_C6000:
8435 sec_type = SHT_C6000_UNWIND;
8436 break;
8437
0b4362b0 8438 default:
74e1a04b 8439 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8440 elf_header.e_machine);
8441 return;
fa197c1c
PB		 8442 }
8443
0b6ae522 8444 if (string_table == NULL)
1b31d05e
NC		 8445 return;
8446
8447 memset (& aux, 0, sizeof (aux));
8448 aux.file = file;
0b6ae522
DJ		 8449
8450 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8451 {
8452 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8453 {
ba5cdace 8454 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8455
8456 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8457
8458 /* PR binutils/17531 file: 011-12666-0.004. */
8459 if (aux.strtab != NULL)
8460 {
4082ef84 8461 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8462 free (aux.strtab);
8463 }
0b6ae522
DJ		 8464 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8465 1, strsec->sh_size, _("string table"));
8466 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8467 }
fa197c1c 8468 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8469 unwsec = sec;
8470 }
8471
1b31d05e 8472 if (unwsec == NULL)
0b6ae522 8473 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8474 else
8475 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8476 {
8477 if (sec->sh_type == sec_type)
8478 {
8479 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8480 printable_section_name (sec),
1b31d05e
NC		 8481 (unsigned long) sec->sh_offset,
8482 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8483
1b31d05e
NC		 8484 dump_arm_unwind (&aux, sec);
8485 }
8486 }
0b6ae522
DJ		 8487
8488 if (aux.symtab)
8489 free (aux.symtab);
8490 if (aux.strtab)
8491 free ((char *) aux.strtab);
0b6ae522
DJ		 8492}
8493
1b31d05e 8494static void
2cf0635d 8495process_unwind (FILE * file)
57346661 8496{
2cf0635d
NC		 8497 struct unwind_handler
8498 {
57346661 8499 int machtype;
1b31d05e 8500 void (* handler)(FILE *);
2cf0635d
NC		 8501 } handlers[] =
8502 {
0b6ae522 8503 { EM_ARM, arm_process_unwind },
57346661
AM		 8504 { EM_IA_64, ia64_process_unwind },
8505 { EM_PARISC, hppa_process_unwind },
fa197c1c 8506 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8507 { 0, 0 }
8508 };
8509 int i;
8510
8511 if (!do_unwind)
1b31d05e 8512 return;
57346661
AM		 8513
8514 for (i = 0; handlers[i].handler != NULL; i++)
8515 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8516 {
8517 handlers[i].handler (file);
8518 return;
8519 }
57346661 8520
1b31d05e
NC		 8521 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8522 get_machine_name (elf_header.e_machine));
57346661
AM		 8523}
8524
252b5132 8525static void
2cf0635d 8526dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8527{
8528 switch (entry->d_tag)
8529 {
8530 case DT_MIPS_FLAGS:
8531 if (entry->d_un.d_val == 0)
4b68bca3 8532 printf (_("NONE"));
252b5132
RH		 8533 else
8534 {
8535 static const char * opts[] =
8536 {
8537 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8538 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8539 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8540 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8541 "RLD_ORDER_SAFE"
8542 };
8543 unsigned int cnt;
8544 int first = 1;
2b692964 8545
60bca95a 8546 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8547 if (entry->d_un.d_val & (1 << cnt))
8548 {
8549 printf ("%s%s", first ? "" : " ", opts[cnt]);
8550 first = 0;
8551 }
252b5132
RH		 8552 }
8553 break;
103f02d3 8554
252b5132 8555 case DT_MIPS_IVERSION:
d79b3d50 8556 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8557 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8558 else
76ca31c0
NC		 8559 {
8560 char buf[40];
8561 sprintf_vma (buf, entry->d_un.d_ptr);
8562 /* Note: coded this way so that there is a single string for translation. */
8563 printf (_("<corrupt: %s>"), buf);
8564 }
252b5132 8565 break;
103f02d3 8566
252b5132
RH		 8567 case DT_MIPS_TIME_STAMP:
8568 {
8569 char timebuf[20];
2cf0635d 8570 struct tm * tmp;
91d6fa6a 8571 time_t atime = entry->d_un.d_val;
82b1b41b 8572
91d6fa6a 8573 tmp = gmtime (&atime);
82b1b41b
NC		 8574 /* PR 17531: file: 6accc532. */
8575 if (tmp == NULL)
8576 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8577 else
8578 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8579 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8580 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8581 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8582 }
8583 break;
103f02d3 8584
252b5132
RH		 8585 case DT_MIPS_RLD_VERSION:
8586 case DT_MIPS_LOCAL_GOTNO:
8587 case DT_MIPS_CONFLICTNO:
8588 case DT_MIPS_LIBLISTNO:
8589 case DT_MIPS_SYMTABNO:
8590 case DT_MIPS_UNREFEXTNO:
8591 case DT_MIPS_HIPAGENO:
8592 case DT_MIPS_DELTA_CLASS_NO:
8593 case DT_MIPS_DELTA_INSTANCE_NO:
8594 case DT_MIPS_DELTA_RELOC_NO:
8595 case DT_MIPS_DELTA_SYM_NO:
8596 case DT_MIPS_DELTA_CLASSSYM_NO:
8597 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8598 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8599 break;
103f02d3
UD		 8600
8601 default:
4b68bca3 8602 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8603 }
4b68bca3 8604 putchar ('\n');
103f02d3
UD		 8605}
8606
103f02d3 8607static void
2cf0635d 8608dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8609{
8610 switch (entry->d_tag)
8611 {
8612 case DT_HP_DLD_FLAGS:
8613 {
8614 static struct
8615 {
8616 long int bit;
2cf0635d 8617 const char * str;
5e220199
NC		 8618 }
8619 flags[] =
8620 {
8621 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8622 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8623 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8624 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8625 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8626 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8627 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8628 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8629 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8630 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8631 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8632 { DT_HP_GST, "HP_GST" },
8633 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8634 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8635 { DT_HP_NODELETE, "HP_NODELETE" },
8636 { DT_HP_GROUP, "HP_GROUP" },
8637 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8638 };
103f02d3 8639 int first = 1;
5e220199 8640 size_t cnt;
f7a99963 8641 bfd_vma val = entry->d_un.d_val;
103f02d3 8642
60bca95a 8643 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8644 if (val & flags[cnt].bit)
30800947
NC		 8645 {
8646 if (! first)
8647 putchar (' ');
8648 fputs (flags[cnt].str, stdout);
8649 first = 0;
8650 val ^= flags[cnt].bit;
8651 }
76da6bbe 8652
103f02d3 8653 if (val != 0 || first)
f7a99963
NC		 8654 {
8655 if (! first)
8656 putchar (' ');
8657 print_vma (val, HEX);
8658 }
103f02d3
UD		 8659 }
8660 break;
76da6bbe 8661
252b5132 8662 default:
f7a99963
NC		 8663 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8664 break;
252b5132 8665 }
35b1837e 8666 putchar ('\n');
252b5132
RH		 8667}
8668
28f997cf
TG		 8669#ifdef BFD64
8670
8671/* VMS vs Unix time offset and factor. */
8672
8673#define VMS_EPOCH_OFFSET 35067168000000000LL
8674#define VMS_GRANULARITY_FACTOR 10000000
8675
8676/* Display a VMS time in a human readable format. */
8677
8678static void
8679print_vms_time (bfd_int64_t vmstime)
8680{
8681 struct tm *tm;
8682 time_t unxtime;
8683
8684 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8685 tm = gmtime (&unxtime);
8686 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8687 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8688 tm->tm_hour, tm->tm_min, tm->tm_sec);
8689}
8690#endif /* BFD64 */
8691
ecc51f48 8692static void
2cf0635d 8693dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8694{
8695 switch (entry->d_tag)
8696 {
0de14b54 8697 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8698 /* First 3 slots reserved. */
ecc51f48
NC		 8699 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8700 printf (" -- ");
8701 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8702 break;
8703
28f997cf
TG		 8704 case DT_IA_64_VMS_LINKTIME:
8705#ifdef BFD64
8706 print_vms_time (entry->d_un.d_val);
8707#endif
8708 break;
8709
8710 case DT_IA_64_VMS_LNKFLAGS:
8711 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8712 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8713 printf (" CALL_DEBUG");
8714 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8715 printf (" NOP0BUFS");
8716 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8717 printf (" P0IMAGE");
8718 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8719 printf (" MKTHREADS");
8720 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8721 printf (" UPCALLS");
8722 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8723 printf (" IMGSTA");
8724 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8725 printf (" INITIALIZE");
8726 if (entry->d_un.d_val & VMS_LF_MAIN)
8727 printf (" MAIN");
8728 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8729 printf (" EXE_INIT");
8730 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8731 printf (" TBK_IN_IMG");
8732 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8733 printf (" DBG_IN_IMG");
8734 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8735 printf (" TBK_IN_DSF");
8736 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8737 printf (" DBG_IN_DSF");
8738 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8739 printf (" SIGNATURES");
8740 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8741 printf (" REL_SEG_OFF");
8742 break;
8743
bdf4d63a
JJ		 8744 default:
8745 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8746 break;
ecc51f48 8747 }
bdf4d63a 8748 putchar ('\n');
ecc51f48
NC		 8749}
8750
252b5132 8751static int
2cf0635d 8752get_32bit_dynamic_section (FILE * file)
252b5132 8753{
2cf0635d
NC		 8754 Elf32_External_Dyn * edyn;
8755 Elf32_External_Dyn * ext;
8756 Elf_Internal_Dyn * entry;
103f02d3 8757
3f5e193b
NC		 8758 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8759 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8760 if (!edyn)
8761 return 0;
103f02d3 8762
071436c6
NC		 8763 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8764 might not have the luxury of section headers. Look for the DT_NULL
8765 terminator to determine the number of entries. */
ba2685cc 8766 for (ext = edyn, dynamic_nent = 0;
53c3012c 8767 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8768 ext++)
8769 {
8770 dynamic_nent++;
8771 if (BYTE_GET (ext->d_tag) == DT_NULL)
8772 break;
8773 }
252b5132 8774
3f5e193b
NC		 8775 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8776 sizeof (* entry));
b2d38a17 8777 if (dynamic_section == NULL)
252b5132 8778 {
8b73c356
NC		 8779 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8780 (unsigned long) dynamic_nent);
9ea033b2
NC		 8781 free (edyn);
8782 return 0;
8783 }
252b5132 8784
fb514b26 8785 for (ext = edyn, entry = dynamic_section;
ba2685cc 8786 entry < dynamic_section + dynamic_nent;
fb514b26 8787 ext++, entry++)
9ea033b2 8788 {
fb514b26
AM		 8789 entry->d_tag = BYTE_GET (ext->d_tag);
8790 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8791 }
8792
9ea033b2
NC		 8793 free (edyn);
8794
8795 return 1;
8796}
8797
8798static int
2cf0635d 8799get_64bit_dynamic_section (FILE * file)
9ea033b2 8800{
2cf0635d
NC		 8801 Elf64_External_Dyn * edyn;
8802 Elf64_External_Dyn * ext;
8803 Elf_Internal_Dyn * entry;
103f02d3 8804
071436c6 8805 /* Read in the data. */
3f5e193b
NC		 8806 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8807 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8808 if (!edyn)
8809 return 0;
103f02d3 8810
071436c6
NC		 8811 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8812 might not have the luxury of section headers. Look for the DT_NULL
8813 terminator to determine the number of entries. */
ba2685cc 8814 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8815 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8816 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8817 ext++)
8818 {
8819 dynamic_nent++;
66543521 8820 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8821 break;
8822 }
252b5132 8823
3f5e193b
NC		 8824 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8825 sizeof (* entry));
b2d38a17 8826 if (dynamic_section == NULL)
252b5132 8827 {
8b73c356
NC		 8828 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8829 (unsigned long) dynamic_nent);
252b5132
RH		 8830 free (edyn);
8831 return 0;
8832 }
8833
071436c6 8834 /* Convert from external to internal formats. */
fb514b26 8835 for (ext = edyn, entry = dynamic_section;
ba2685cc 8836 entry < dynamic_section + dynamic_nent;
fb514b26 8837 ext++, entry++)
252b5132 8838 {
66543521
AM		 8839 entry->d_tag = BYTE_GET (ext->d_tag);
8840 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8841 }
8842
8843 free (edyn);
8844
9ea033b2
NC		 8845 return 1;
8846}
8847
e9e44622
JJ		 8848static void
8849print_dynamic_flags (bfd_vma flags)
d1133906 8850{
e9e44622 8851 int first = 1;
13ae64f3 8852
d1133906
NC		 8853 while (flags)
8854 {
8855 bfd_vma flag;
8856
8857 flag = flags & - flags;
8858 flags &= ~ flag;
8859
e9e44622
JJ		 8860 if (first)
8861 first = 0;
8862 else
8863 putc (' ', stdout);
13ae64f3 8864
d1133906
NC		 8865 switch (flag)
8866 {
e9e44622
JJ		 8867 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8868 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8869 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8870 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8871 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8872 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8873 }
8874 }
e9e44622 8875 puts ("");
d1133906
NC		 8876}
8877
b2d38a17
NC		 8878/* Parse and display the contents of the dynamic section. */
8879
9ea033b2 8880static int
2cf0635d 8881process_dynamic_section (FILE * file)
9ea033b2 8882{
2cf0635d 8883 Elf_Internal_Dyn * entry;
9ea033b2
NC		 8884
8885 if (dynamic_size == 0)
8886 {
8887 if (do_dynamic)
b2d38a17 8888 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 8889
8890 return 1;
8891 }
8892
8893 if (is_32bit_elf)
8894 {
b2d38a17 8895 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 8896 return 0;
8897 }
b2d38a17 8898 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 8899 return 0;
8900
252b5132
RH		 8901 /* Find the appropriate symbol table. */
8902 if (dynamic_symbols == NULL)
8903 {
86dba8ee
AM		 8904 for (entry = dynamic_section;
8905 entry < dynamic_section + dynamic_nent;
8906 ++entry)
252b5132 8907 {
c8286bd1 8908 Elf_Internal_Shdr section;
252b5132
RH		 8909
8910 if (entry->d_tag != DT_SYMTAB)
8911 continue;
8912
8913 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8914
8915 /* Since we do not know how big the symbol table is,
8916 we default to reading in the entire file (!) and
8917 processing that. This is overkill, I know, but it
e3c8793a 8918 should work. */
d93f0186 8919 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 8920
fb52b2f4
NC		 8921 if (archive_file_offset != 0)
8922 section.sh_size = archive_file_size - section.sh_offset;
8923 else
8924 {
8925 if (fseek (file, 0, SEEK_END))
591a748a 8926 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 8927
8928 section.sh_size = ftell (file) - section.sh_offset;
8929 }
252b5132 8930
9ea033b2 8931 if (is_32bit_elf)
9ad5cbcf 8932 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 8933 else
9ad5cbcf 8934 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 8935 section.sh_name = string_table_length;
252b5132 8936
ba5cdace 8937 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 8938 if (num_dynamic_syms < 1)
252b5132
RH		 8939 {
8940 error (_("Unable to determine the number of symbols to load\n"));
8941 continue;
8942 }
252b5132
RH		 8943 }
8944 }
8945
8946 /* Similarly find a string table. */
8947 if (dynamic_strings == NULL)
8948 {
86dba8ee
AM		 8949 for (entry = dynamic_section;
8950 entry < dynamic_section + dynamic_nent;
8951 ++entry)
252b5132
RH		 8952 {
8953 unsigned long offset;
b34976b6 8954 long str_tab_len;
252b5132
RH		 8955
8956 if (entry->d_tag != DT_STRTAB)
8957 continue;
8958
8959 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8960
8961 /* Since we do not know how big the string table is,
8962 we default to reading in the entire file (!) and
8963 processing that. This is overkill, I know, but it
e3c8793a 8964 should work. */
252b5132 8965
d93f0186 8966 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 8967
8968 if (archive_file_offset != 0)
8969 str_tab_len = archive_file_size - offset;
8970 else
8971 {
8972 if (fseek (file, 0, SEEK_END))
8973 error (_("Unable to seek to end of file\n"));
8974 str_tab_len = ftell (file) - offset;
8975 }
252b5132
RH		 8976
8977 if (str_tab_len < 1)
8978 {
8979 error
8980 (_("Unable to determine the length of the dynamic string table\n"));
8981 continue;
8982 }
8983
3f5e193b
NC		 8984 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8985 str_tab_len,
8986 _("dynamic string table"));
59245841 8987 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 8988 break;
8989 }
8990 }
8991
8992 /* And find the syminfo section if available. */
8993 if (dynamic_syminfo == NULL)
8994 {
3e8bba36 8995 unsigned long syminsz = 0;
252b5132 8996
86dba8ee
AM		 8997 for (entry = dynamic_section;
8998 entry < dynamic_section + dynamic_nent;
8999 ++entry)
252b5132
RH		 9000 {
9001 if (entry->d_tag == DT_SYMINENT)
9002 {
9003 /* Note: these braces are necessary to avoid a syntax
9004 error from the SunOS4 C compiler. */
049b0c3a
NC		 9005 /* PR binutils/17531: A corrupt file can trigger this test.
9006 So do not use an assert, instead generate an error message. */
9007 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9008 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9009 (int) entry->d_un.d_val);
252b5132
RH		 9010 }
9011 else if (entry->d_tag == DT_SYMINSZ)
9012 syminsz = entry->d_un.d_val;
9013 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9014 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9015 syminsz);
252b5132
RH		 9016 }
9017
9018 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9019 {
2cf0635d
NC		 9020 Elf_External_Syminfo * extsyminfo;
9021 Elf_External_Syminfo * extsym;
9022 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9023
9024 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9025 extsyminfo = (Elf_External_Syminfo *)
9026 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9027 _("symbol information"));
a6e9f9df
AM		 9028 if (!extsyminfo)
9029 return 0;
252b5132 9030
3f5e193b 9031 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9032 if (dynamic_syminfo == NULL)
9033 {
8b73c356
NC		 9034 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9035 (unsigned long) syminsz);
252b5132
RH		 9036 return 0;
9037 }
9038
9039 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9040 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9041 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9042 ++syminfo, ++extsym)
252b5132 9043 {
86dba8ee
AM		 9044 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9045 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9046 }
9047
9048 free (extsyminfo);
9049 }
9050 }
9051
9052 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9053 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9054 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9055 if (do_dynamic)
9056 printf (_(" Tag Type Name/Value\n"));
9057
86dba8ee
AM		 9058 for (entry = dynamic_section;
9059 entry < dynamic_section + dynamic_nent;
9060 entry++)
252b5132
RH		 9061 {
9062 if (do_dynamic)
f7a99963 9063 {
2cf0635d 9064 const char * dtype;
e699b9ff 9065
f7a99963
NC		 9066 putchar (' ');
9067 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9068 dtype = get_dynamic_type (entry->d_tag);
9069 printf (" (%s)%*s", dtype,
9070 ((is_32bit_elf ? 27 : 19)
9071 - (int) strlen (dtype)),
f7a99963
NC		 9072 " ");
9073 }
252b5132
RH		 9074
9075 switch (entry->d_tag)
9076 {
d1133906
NC		 9077 case DT_FLAGS:
9078 if (do_dynamic)
e9e44622 9079 print_dynamic_flags (entry->d_un.d_val);
d1133906 9080 break;
76da6bbe 9081
252b5132
RH		 9082 case DT_AUXILIARY:
9083 case DT_FILTER:
019148e4
L		 9084 case DT_CONFIG:
9085 case DT_DEPAUDIT:
9086 case DT_AUDIT:
252b5132
RH		 9087 if (do_dynamic)
9088 {
019148e4 9089 switch (entry->d_tag)
b34976b6 9090 {
019148e4
L		 9091 case DT_AUXILIARY:
9092 printf (_("Auxiliary library"));
9093 break;
9094
9095 case DT_FILTER:
9096 printf (_("Filter library"));
9097 break;
9098
b34976b6 9099 case DT_CONFIG:
019148e4
L		 9100 printf (_("Configuration file"));
9101 break;
9102
9103 case DT_DEPAUDIT:
9104 printf (_("Dependency audit library"));
9105 break;
9106
9107 case DT_AUDIT:
9108 printf (_("Audit library"));
9109 break;
9110 }
252b5132 9111
d79b3d50
NC		 9112 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9113 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9114 else
f7a99963
NC		 9115 {
9116 printf (": ");
9117 print_vma (entry->d_un.d_val, PREFIX_HEX);
9118 putchar ('\n');
9119 }
252b5132
RH		 9120 }
9121 break;
9122
dcefbbbd 9123 case DT_FEATURE:
252b5132
RH		 9124 if (do_dynamic)
9125 {
9126 printf (_("Flags:"));
86f55779 9127
252b5132
RH		 9128 if (entry->d_un.d_val == 0)
9129 printf (_(" None\n"));
9130 else
9131 {
9132 unsigned long int val = entry->d_un.d_val;
86f55779 9133
252b5132
RH		 9134 if (val & DTF_1_PARINIT)
9135 {
9136 printf (" PARINIT");
9137 val ^= DTF_1_PARINIT;
9138 }
dcefbbbd
L		 9139 if (val & DTF_1_CONFEXP)
9140 {
9141 printf (" CONFEXP");
9142 val ^= DTF_1_CONFEXP;
9143 }
252b5132
RH		 9144 if (val != 0)
9145 printf (" %lx", val);
9146 puts ("");
9147 }
9148 }
9149 break;
9150
9151 case DT_POSFLAG_1:
9152 if (do_dynamic)
9153 {
9154 printf (_("Flags:"));
86f55779 9155
252b5132
RH		 9156 if (entry->d_un.d_val == 0)
9157 printf (_(" None\n"));
9158 else
9159 {
9160 unsigned long int val = entry->d_un.d_val;
86f55779 9161
252b5132
RH		 9162 if (val & DF_P1_LAZYLOAD)
9163 {
9164 printf (" LAZYLOAD");
9165 val ^= DF_P1_LAZYLOAD;
9166 }
9167 if (val & DF_P1_GROUPPERM)
9168 {
9169 printf (" GROUPPERM");
9170 val ^= DF_P1_GROUPPERM;
9171 }
9172 if (val != 0)
9173 printf (" %lx", val);
9174 puts ("");
9175 }
9176 }
9177 break;
9178
9179 case DT_FLAGS_1:
9180 if (do_dynamic)
9181 {
9182 printf (_("Flags:"));
9183 if (entry->d_un.d_val == 0)
9184 printf (_(" None\n"));
9185 else
9186 {
9187 unsigned long int val = entry->d_un.d_val;
86f55779 9188
252b5132
RH		 9189 if (val & DF_1_NOW)
9190 {
9191 printf (" NOW");
9192 val ^= DF_1_NOW;
9193 }
9194 if (val & DF_1_GLOBAL)
9195 {
9196 printf (" GLOBAL");
9197 val ^= DF_1_GLOBAL;
9198 }
9199 if (val & DF_1_GROUP)
9200 {
9201 printf (" GROUP");
9202 val ^= DF_1_GROUP;
9203 }
9204 if (val & DF_1_NODELETE)
9205 {
9206 printf (" NODELETE");
9207 val ^= DF_1_NODELETE;
9208 }
9209 if (val & DF_1_LOADFLTR)
9210 {
9211 printf (" LOADFLTR");
9212 val ^= DF_1_LOADFLTR;
9213 }
9214 if (val & DF_1_INITFIRST)
9215 {
9216 printf (" INITFIRST");
9217 val ^= DF_1_INITFIRST;
9218 }
9219 if (val & DF_1_NOOPEN)
9220 {
9221 printf (" NOOPEN");
9222 val ^= DF_1_NOOPEN;
9223 }
9224 if (val & DF_1_ORIGIN)
9225 {
9226 printf (" ORIGIN");
9227 val ^= DF_1_ORIGIN;
9228 }
9229 if (val & DF_1_DIRECT)
9230 {
9231 printf (" DIRECT");
9232 val ^= DF_1_DIRECT;
9233 }
9234 if (val & DF_1_TRANS)
9235 {
9236 printf (" TRANS");
9237 val ^= DF_1_TRANS;
9238 }
9239 if (val & DF_1_INTERPOSE)
9240 {
9241 printf (" INTERPOSE");
9242 val ^= DF_1_INTERPOSE;
9243 }
f7db6139 9244 if (val & DF_1_NODEFLIB)
dcefbbbd 9245 {
f7db6139
L		 9246 printf (" NODEFLIB");
9247 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9248 }
9249 if (val & DF_1_NODUMP)
9250 {
9251 printf (" NODUMP");
9252 val ^= DF_1_NODUMP;
9253 }
34b60028 9254 if (val & DF_1_CONFALT)
dcefbbbd 9255 {
34b60028
L		 9256 printf (" CONFALT");
9257 val ^= DF_1_CONFALT;
9258 }
9259 if (val & DF_1_ENDFILTEE)
9260 {
9261 printf (" ENDFILTEE");
9262 val ^= DF_1_ENDFILTEE;
9263 }
9264 if (val & DF_1_DISPRELDNE)
9265 {
9266 printf (" DISPRELDNE");
9267 val ^= DF_1_DISPRELDNE;
9268 }
9269 if (val & DF_1_DISPRELPND)
9270 {
9271 printf (" DISPRELPND");
9272 val ^= DF_1_DISPRELPND;
9273 }
9274 if (val & DF_1_NODIRECT)
9275 {
9276 printf (" NODIRECT");
9277 val ^= DF_1_NODIRECT;
9278 }
9279 if (val & DF_1_IGNMULDEF)
9280 {
9281 printf (" IGNMULDEF");
9282 val ^= DF_1_IGNMULDEF;
9283 }
9284 if (val & DF_1_NOKSYMS)
9285 {
9286 printf (" NOKSYMS");
9287 val ^= DF_1_NOKSYMS;
9288 }
9289 if (val & DF_1_NOHDR)
9290 {
9291 printf (" NOHDR");
9292 val ^= DF_1_NOHDR;
9293 }
9294 if (val & DF_1_EDITED)
9295 {
9296 printf (" EDITED");
9297 val ^= DF_1_EDITED;
9298 }
9299 if (val & DF_1_NORELOC)
9300 {
9301 printf (" NORELOC");
9302 val ^= DF_1_NORELOC;
9303 }
9304 if (val & DF_1_SYMINTPOSE)
9305 {
9306 printf (" SYMINTPOSE");
9307 val ^= DF_1_SYMINTPOSE;
9308 }
9309 if (val & DF_1_GLOBAUDIT)
9310 {
9311 printf (" GLOBAUDIT");
9312 val ^= DF_1_GLOBAUDIT;
9313 }
9314 if (val & DF_1_SINGLETON)
9315 {
9316 printf (" SINGLETON");
9317 val ^= DF_1_SINGLETON;
dcefbbbd 9318 }
5c383f02
RO		 9319 if (val & DF_1_STUB)
9320 {
9321 printf (" STUB");
9322 val ^= DF_1_STUB;
9323 }
9324 if (val & DF_1_PIE)
9325 {
9326 printf (" PIE");
9327 val ^= DF_1_PIE;
9328 }
252b5132
RH		 9329 if (val != 0)
9330 printf (" %lx", val);
9331 puts ("");
9332 }
9333 }
9334 break;
9335
9336 case DT_PLTREL:
566b0d53 9337 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9338 if (do_dynamic)
9339 puts (get_dynamic_type (entry->d_un.d_val));
9340 break;
9341
9342 case DT_NULL :
9343 case DT_NEEDED :
9344 case DT_PLTGOT :
9345 case DT_HASH :
9346 case DT_STRTAB :
9347 case DT_SYMTAB :
9348 case DT_RELA :
9349 case DT_INIT :
9350 case DT_FINI :
9351 case DT_SONAME :
9352 case DT_RPATH :
9353 case DT_SYMBOLIC:
9354 case DT_REL :
9355 case DT_DEBUG :
9356 case DT_TEXTREL :
9357 case DT_JMPREL :
019148e4 9358 case DT_RUNPATH :
252b5132
RH		 9359 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9360
9361 if (do_dynamic)
9362 {
2cf0635d 9363 char * name;
252b5132 9364
d79b3d50
NC		 9365 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9366 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9367 else
d79b3d50 9368 name = NULL;
252b5132
RH		 9369
9370 if (name)
9371 {
9372 switch (entry->d_tag)
9373 {
9374 case DT_NEEDED:
9375 printf (_("Shared library: [%s]"), name);
9376
18bd398b 9377 if (streq (name, program_interpreter))
f7a99963 9378 printf (_(" program interpreter"));
252b5132
RH		 9379 break;
9380
9381 case DT_SONAME:
f7a99963 9382 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9383 break;
9384
9385 case DT_RPATH:
f7a99963 9386 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9387 break;
9388
019148e4
L		 9389 case DT_RUNPATH:
9390 printf (_("Library runpath: [%s]"), name);
9391 break;
9392
252b5132 9393 default:
f7a99963
NC		 9394 print_vma (entry->d_un.d_val, PREFIX_HEX);
9395 break;
252b5132
RH		 9396 }
9397 }
9398 else
f7a99963
NC		 9399 print_vma (entry->d_un.d_val, PREFIX_HEX);
9400
9401 putchar ('\n');
252b5132
RH		 9402 }
9403 break;
9404
9405 case DT_PLTRELSZ:
9406 case DT_RELASZ :
9407 case DT_STRSZ :
9408 case DT_RELSZ :
9409 case DT_RELAENT :
9410 case DT_SYMENT :
9411 case DT_RELENT :
566b0d53 9412 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9413 case DT_PLTPADSZ:
9414 case DT_MOVEENT :
9415 case DT_MOVESZ :
9416 case DT_INIT_ARRAYSZ:
9417 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9418 case DT_GNU_CONFLICTSZ:
9419 case DT_GNU_LIBLISTSZ:
252b5132 9420 if (do_dynamic)
f7a99963
NC		 9421 {
9422 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9423 printf (_(" (bytes)\n"));
f7a99963 9424 }
252b5132
RH		 9425 break;
9426
9427 case DT_VERDEFNUM:
9428 case DT_VERNEEDNUM:
9429 case DT_RELACOUNT:
9430 case DT_RELCOUNT:
9431 if (do_dynamic)
f7a99963
NC		 9432 {
9433 print_vma (entry->d_un.d_val, UNSIGNED);
9434 putchar ('\n');
9435 }
252b5132
RH		 9436 break;
9437
9438 case DT_SYMINSZ:
9439 case DT_SYMINENT:
9440 case DT_SYMINFO:
9441 case DT_USED:
9442 case DT_INIT_ARRAY:
9443 case DT_FINI_ARRAY:
9444 if (do_dynamic)
9445 {
d79b3d50
NC		 9446 if (entry->d_tag == DT_USED
9447 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9448 {
2cf0635d 9449 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9450
b34976b6 9451 if (*name)
252b5132
RH		 9452 {
9453 printf (_("Not needed object: [%s]\n"), name);
9454 break;
9455 }
9456 }
103f02d3 9457
f7a99963
NC		 9458 print_vma (entry->d_un.d_val, PREFIX_HEX);
9459 putchar ('\n');
252b5132
RH		 9460 }
9461 break;
9462
9463 case DT_BIND_NOW:
9464 /* The value of this entry is ignored. */
35b1837e
AM		 9465 if (do_dynamic)
9466 putchar ('\n');
252b5132 9467 break;
103f02d3 9468
047b2264
JJ		 9469 case DT_GNU_PRELINKED:
9470 if (do_dynamic)
9471 {
2cf0635d 9472 struct tm * tmp;
91d6fa6a 9473 time_t atime = entry->d_un.d_val;
047b2264 9474
91d6fa6a 9475 tmp = gmtime (&atime);
071436c6
NC		 9476 /* PR 17533 file: 041-1244816-0.004. */
9477 if (tmp == NULL)
5a2cbcf4
L		 9478 printf (_("<corrupt time val: %lx"),
9479 (unsigned long) atime);
071436c6
NC		 9480 else
9481 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9482 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9483 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9484
9485 }
9486 break;
9487
fdc90cb4
JJ		 9488 case DT_GNU_HASH:
9489 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9490 if (do_dynamic)
9491 {
9492 print_vma (entry->d_un.d_val, PREFIX_HEX);
9493 putchar ('\n');
9494 }
9495 break;
9496
252b5132
RH		 9497 default:
9498 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9499 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9500 entry->d_un.d_val;
9501
9502 if (do_dynamic)
9503 {
9504 switch (elf_header.e_machine)
9505 {
9506 case EM_MIPS:
4fe85591 9507 case EM_MIPS_RS3_LE:
b2d38a17 9508 dynamic_section_mips_val (entry);
252b5132 9509 break;
103f02d3 9510 case EM_PARISC:
b2d38a17 9511 dynamic_section_parisc_val (entry);
103f02d3 9512 break;
ecc51f48 9513 case EM_IA_64:
b2d38a17 9514 dynamic_section_ia64_val (entry);
ecc51f48 9515 break;
252b5132 9516 default:
f7a99963
NC		 9517 print_vma (entry->d_un.d_val, PREFIX_HEX);
9518 putchar ('\n');
252b5132
RH		 9519 }
9520 }
9521 break;
9522 }
9523 }
9524
9525 return 1;
9526}
9527
9528static char *
d3ba0551 9529get_ver_flags (unsigned int flags)
252b5132 9530{
b34976b6 9531 static char buff[32];
252b5132
RH		 9532
9533 buff[0] = 0;
9534
9535 if (flags == 0)
9536 return _("none");
9537
9538 if (flags & VER_FLG_BASE)
9539 strcat (buff, "BASE ");
9540
9541 if (flags & VER_FLG_WEAK)
9542 {
9543 if (flags & VER_FLG_BASE)
9544 strcat (buff, "| ");
9545
9546 strcat (buff, "WEAK ");
9547 }
9548
44ec90b9
RO		 9549 if (flags & VER_FLG_INFO)
9550 {
9551 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9552 strcat (buff, "| ");
9553
9554 strcat (buff, "INFO ");
9555 }
9556
9557 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9558 strcat (buff, _("| <unknown>"));
252b5132
RH		 9559
9560 return buff;
9561}
9562
9563/* Display the contents of the version sections. */
98fb390a 9564
252b5132 9565static int
2cf0635d 9566process_version_sections (FILE * file)
252b5132 9567{
2cf0635d 9568 Elf_Internal_Shdr * section;
b34976b6
AM		 9569 unsigned i;
9570 int found = 0;
252b5132
RH		 9571
9572 if (! do_version)
9573 return 1;
9574
9575 for (i = 0, section = section_headers;
9576 i < elf_header.e_shnum;
b34976b6 9577 i++, section++)
252b5132
RH		 9578 {
9579 switch (section->sh_type)
9580 {
9581 case SHT_GNU_verdef:
9582 {
2cf0635d 9583 Elf_External_Verdef * edefs;
b34976b6
AM		 9584 unsigned int idx;
9585 unsigned int cnt;
2cf0635d 9586 char * endbuf;
252b5132
RH		 9587
9588 found = 1;
9589
74e1a04b
NC		 9590 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9591 printable_section_name (section),
9592 section->sh_info);
252b5132
RH		 9593
9594 printf (_(" Addr: 0x"));
9595 printf_vma (section->sh_addr);
74e1a04b 9596 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9597 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9598 printable_section_name_from_index (section->sh_link));
252b5132 9599
3f5e193b
NC		 9600 edefs = (Elf_External_Verdef *)
9601 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9602 _("version definition section"));
a6e9f9df
AM		 9603 if (!edefs)
9604 break;
59245841 9605 endbuf = (char *) edefs + section->sh_size;
252b5132 9606
b34976b6 9607 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9608 {
2cf0635d
NC		 9609 char * vstart;
9610 Elf_External_Verdef * edef;
b34976b6 9611 Elf_Internal_Verdef ent;
2cf0635d 9612 Elf_External_Verdaux * eaux;
b34976b6
AM		 9613 Elf_Internal_Verdaux aux;
9614 int j;
9615 int isum;
103f02d3 9616
7e26601c
NC		 9617 /* Check for very large indicies. */
9618 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9619 break;
9620
252b5132 9621 vstart = ((char *) edefs) + idx;
54806181
AM		 9622 if (vstart + sizeof (*edef) > endbuf)
9623 break;
252b5132
RH		 9624
9625 edef = (Elf_External_Verdef *) vstart;
9626
9627 ent.vd_version = BYTE_GET (edef->vd_version);
9628 ent.vd_flags = BYTE_GET (edef->vd_flags);
9629 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9630 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9631 ent.vd_hash = BYTE_GET (edef->vd_hash);
9632 ent.vd_aux = BYTE_GET (edef->vd_aux);
9633 ent.vd_next = BYTE_GET (edef->vd_next);
9634
9635 printf (_(" %#06x: Rev: %d Flags: %s"),
9636 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9637
9638 printf (_(" Index: %d Cnt: %d "),
9639 ent.vd_ndx, ent.vd_cnt);
9640
dd24e3da 9641 /* Check for overflow. */
7e26601c 9642 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9643 break;
9644
252b5132
RH		 9645 vstart += ent.vd_aux;
9646
9647 eaux = (Elf_External_Verdaux *) vstart;
9648
9649 aux.vda_name = BYTE_GET (eaux->vda_name);
9650 aux.vda_next = BYTE_GET (eaux->vda_next);
9651
d79b3d50
NC		 9652 if (VALID_DYNAMIC_NAME (aux.vda_name))
9653 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9654 else
9655 printf (_("Name index: %ld\n"), aux.vda_name);
9656
9657 isum = idx + ent.vd_aux;
9658
b34976b6 9659 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9660 {
dd24e3da 9661 /* Check for overflow. */
7e26601c 9662 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9663 break;
9664
252b5132
RH		 9665 isum += aux.vda_next;
9666 vstart += aux.vda_next;
9667
9668 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9669 if (vstart + sizeof (*eaux) > endbuf)
9670 break;
252b5132
RH		 9671
9672 aux.vda_name = BYTE_GET (eaux->vda_name);
9673 aux.vda_next = BYTE_GET (eaux->vda_next);
9674
d79b3d50 9675 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9676 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9677 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9678 else
9679 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9680 isum, j, aux.vda_name);
9681 }
dd24e3da 9682
54806181
AM		 9683 if (j < ent.vd_cnt)
9684 printf (_(" Version def aux past end of section\n"));
252b5132 9685
5d921cbd
NC		 9686 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9687 if (idx + ent.vd_next <= idx)
9688 break;
9689
252b5132
RH		 9690 idx += ent.vd_next;
9691 }
dd24e3da 9692
54806181
AM		 9693 if (cnt < section->sh_info)
9694 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9695
9696 free (edefs);
9697 }
9698 break;
103f02d3 9699
252b5132
RH		 9700 case SHT_GNU_verneed:
9701 {
2cf0635d 9702 Elf_External_Verneed * eneed;
b34976b6
AM		 9703 unsigned int idx;
9704 unsigned int cnt;
2cf0635d 9705 char * endbuf;
252b5132
RH		 9706
9707 found = 1;
9708
72de5009 9709 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9710 printable_section_name (section), section->sh_info);
252b5132
RH		 9711
9712 printf (_(" Addr: 0x"));
9713 printf_vma (section->sh_addr);
72de5009 9714 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9715 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9716 printable_section_name_from_index (section->sh_link));
252b5132 9717
3f5e193b
NC		 9718 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9719 section->sh_offset, 1,
9720 section->sh_size,
9cf03b7e 9721 _("Version Needs section"));
a6e9f9df
AM		 9722 if (!eneed)
9723 break;
59245841 9724 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9725
9726 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9727 {
2cf0635d 9728 Elf_External_Verneed * entry;
b34976b6
AM		 9729 Elf_Internal_Verneed ent;
9730 int j;
9731 int isum;
2cf0635d 9732 char * vstart;
252b5132 9733
7e26601c 9734 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9735 break;
9736
252b5132 9737 vstart = ((char *) eneed) + idx;
54806181
AM		 9738 if (vstart + sizeof (*entry) > endbuf)
9739 break;
252b5132
RH		 9740
9741 entry = (Elf_External_Verneed *) vstart;
9742
9743 ent.vn_version = BYTE_GET (entry->vn_version);
9744 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9745 ent.vn_file = BYTE_GET (entry->vn_file);
9746 ent.vn_aux = BYTE_GET (entry->vn_aux);
9747 ent.vn_next = BYTE_GET (entry->vn_next);
9748
9749 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9750
d79b3d50
NC		 9751 if (VALID_DYNAMIC_NAME (ent.vn_file))
9752 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9753 else
9754 printf (_(" File: %lx"), ent.vn_file);
9755
9756 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9757
dd24e3da 9758 /* Check for overflow. */
7e26601c 9759 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9760 break;
252b5132
RH		 9761 vstart += ent.vn_aux;
9762
9763 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9764 {
2cf0635d 9765 Elf_External_Vernaux * eaux;
b34976b6 9766 Elf_Internal_Vernaux aux;
252b5132 9767
54806181
AM		 9768 if (vstart + sizeof (*eaux) > endbuf)
9769 break;
252b5132
RH		 9770 eaux = (Elf_External_Vernaux *) vstart;
9771
9772 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9773 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9774 aux.vna_other = BYTE_GET (eaux->vna_other);
9775 aux.vna_name = BYTE_GET (eaux->vna_name);
9776 aux.vna_next = BYTE_GET (eaux->vna_next);
9777
d79b3d50 9778 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9779 printf (_(" %#06x: Name: %s"),
d79b3d50 9780 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9781 else
ecc2063b 9782 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9783 isum, aux.vna_name);
9784
9785 printf (_(" Flags: %s Version: %d\n"),
9786 get_ver_flags (aux.vna_flags), aux.vna_other);
9787
dd24e3da 9788 /* Check for overflow. */
53774b7e
NC		 9789 if (aux.vna_next > (size_t) (endbuf - vstart)
9790 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9791 {
9792 warn (_("Invalid vna_next field of %lx\n"),
9793 aux.vna_next);
9794 j = ent.vn_cnt;
9795 break;
9796 }
252b5132
RH		 9797 isum += aux.vna_next;
9798 vstart += aux.vna_next;
9799 }
9cf03b7e 9800
54806181 9801 if (j < ent.vn_cnt)
9cf03b7e 9802 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9803
bcf83b2a 9804 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9805 {
9806 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9807 cnt = section->sh_info;
9808 break;
9809 }
252b5132
RH		 9810 idx += ent.vn_next;
9811 }
9cf03b7e 9812
54806181 9813 if (cnt < section->sh_info)
9cf03b7e 9814 warn (_("Missing Version Needs information\n"));
103f02d3 9815
252b5132
RH		 9816 free (eneed);
9817 }
9818 break;
9819
9820 case SHT_GNU_versym:
9821 {
2cf0635d 9822 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9823 size_t total;
9824 unsigned int cnt;
2cf0635d
NC		 9825 unsigned char * edata;
9826 unsigned short * data;
9827 char * strtab;
9828 Elf_Internal_Sym * symbols;
9829 Elf_Internal_Shdr * string_sec;
ba5cdace 9830 unsigned long num_syms;
d3ba0551 9831 long off;
252b5132 9832
4fbb74a6 9833 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9834 break;
9835
4fbb74a6 9836 link_section = section_headers + section->sh_link;
08d8fa11 9837 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9838
4fbb74a6 9839 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9840 break;
9841
252b5132
RH		 9842 found = 1;
9843
ba5cdace 9844 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9845 if (symbols == NULL)
9846 break;
252b5132 9847
4fbb74a6 9848 string_sec = section_headers + link_section->sh_link;
252b5132 9849
3f5e193b
NC		 9850 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9851 string_sec->sh_size,
9852 _("version string table"));
a6e9f9df 9853 if (!strtab)
0429c154
MS		 9854 {
9855 free (symbols);
9856 break;
9857 }
252b5132 9858
8b73c356
NC		 9859 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9860 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9861
9862 printf (_(" Addr: "));
9863 printf_vma (section->sh_addr);
72de5009 9864 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9865 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9866 printable_section_name (link_section));
252b5132 9867
d3ba0551
AM		 9868 off = offset_from_vma (file,
9869 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9870 total * sizeof (short));
3f5e193b
NC		 9871 edata = (unsigned char *) get_data (NULL, file, off, total,
9872 sizeof (short),
9873 _("version symbol data"));
a6e9f9df
AM		 9874 if (!edata)
9875 {
9876 free (strtab);
0429c154 9877 free (symbols);
a6e9f9df
AM		 9878 break;
9879 }
252b5132 9880
3f5e193b 9881 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 9882
9883 for (cnt = total; cnt --;)
b34976b6
AM		 9884 data[cnt] = byte_get (edata + cnt * sizeof (short),
9885 sizeof (short));
252b5132
RH		 9886
9887 free (edata);
9888
9889 for (cnt = 0; cnt < total; cnt += 4)
9890 {
9891 int j, nn;
00d93f34 9892 int check_def, check_need;
2cf0635d 9893 char * name;
252b5132
RH		 9894
9895 printf (" %03x:", cnt);
9896
9897 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 9898 switch (data[cnt + j])
252b5132
RH		 9899 {
9900 case 0:
9901 fputs (_(" 0 (*local*) "), stdout);
9902 break;
9903
9904 case 1:
9905 fputs (_(" 1 (*global*) "), stdout);
9906 break;
9907
9908 default:
c244d050
NC		 9909 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9910 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 9911
dd24e3da 9912 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 9913 array, break to avoid an out-of-bounds read. */
9914 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 9915 {
9916 warn (_("invalid index into symbol array\n"));
9917 break;
9918 }
9919
00d93f34
JJ		 9920 check_def = 1;
9921 check_need = 1;
4fbb74a6
AM		 9922 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9923 || section_headers[symbols[cnt + j].st_shndx].sh_type
c256ffe7 9924 != SHT_NOBITS)
252b5132 9925 {
b34976b6 9926 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
00d93f34
JJ		 9927 check_def = 0;
9928 else
9929 check_need = 0;
252b5132 9930 }
00d93f34
JJ		 9931
9932 if (check_need
b34976b6 9933 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 9934 {
b34976b6
AM		 9935 Elf_Internal_Verneed ivn;
9936 unsigned long offset;
252b5132 9937
d93f0186
NC		 9938 offset = offset_from_vma
9939 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9940 sizeof (Elf_External_Verneed));
252b5132 9941
b34976b6 9942 do
252b5132 9943 {
b34976b6
AM		 9944 Elf_Internal_Vernaux ivna;
9945 Elf_External_Verneed evn;
9946 Elf_External_Vernaux evna;
9947 unsigned long a_off;
252b5132 9948
59245841
NC		 9949 if (get_data (&evn, file, offset, sizeof (evn), 1,
9950 _("version need")) == NULL)
9951 break;
0b4362b0 9952
252b5132
RH		 9953 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9954 ivn.vn_next = BYTE_GET (evn.vn_next);
9955
9956 a_off = offset + ivn.vn_aux;
9957
9958 do
9959 {
59245841
NC		 9960 if (get_data (&evna, file, a_off, sizeof (evna),
9961 1, _("version need aux (2)")) == NULL)
9962 {
9963 ivna.vna_next = 0;
9964 ivna.vna_other = 0;
9965 }
9966 else
9967 {
9968 ivna.vna_next = BYTE_GET (evna.vna_next);
9969 ivna.vna_other = BYTE_GET (evna.vna_other);
9970 }
252b5132
RH		 9971
9972 a_off += ivna.vna_next;
9973 }
b34976b6 9974 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 9975 && ivna.vna_next != 0);
9976
b34976b6 9977 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 9978 {
9979 ivna.vna_name = BYTE_GET (evna.vna_name);
9980
54806181
AM		 9981 if (ivna.vna_name >= string_sec->sh_size)
9982 name = _("*invalid*");
9983 else
9984 name = strtab + ivna.vna_name;
252b5132 9985 nn += printf ("(%s%-*s",
16062207
ILT		 9986 name,
9987 12 - (int) strlen (name),
252b5132 9988 ")");
00d93f34 9989 check_def = 0;
252b5132
RH		 9990 break;
9991 }
9992
9993 offset += ivn.vn_next;
9994 }
9995 while (ivn.vn_next);
9996 }
00d93f34 9997
b34976b6
AM		 9998 if (check_def && data[cnt + j] != 0x8001
9999 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10000 {
b34976b6
AM		 10001 Elf_Internal_Verdef ivd;
10002 Elf_External_Verdef evd;
10003 unsigned long offset;
252b5132 10004
d93f0186
NC		 10005 offset = offset_from_vma
10006 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10007 sizeof evd);
252b5132
RH		 10008
10009 do
10010 {
59245841
NC		 10011 if (get_data (&evd, file, offset, sizeof (evd), 1,
10012 _("version def")) == NULL)
10013 {
10014 ivd.vd_next = 0;
948f632f 10015 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10016 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10017 break;
59245841
NC		 10018 }
10019 else
10020 {
10021 ivd.vd_next = BYTE_GET (evd.vd_next);
10022 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10023 }
252b5132
RH		 10024
10025 offset += ivd.vd_next;
10026 }
c244d050 10027 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10028 && ivd.vd_next != 0);
10029
c244d050 10030 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10031 {
b34976b6
AM		 10032 Elf_External_Verdaux evda;
10033 Elf_Internal_Verdaux ivda;
252b5132
RH		 10034
10035 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10036
59245841
NC		 10037 if (get_data (&evda, file,
10038 offset - ivd.vd_next + ivd.vd_aux,
10039 sizeof (evda), 1,
10040 _("version def aux")) == NULL)
10041 break;
252b5132
RH		 10042
10043 ivda.vda_name = BYTE_GET (evda.vda_name);
10044
54806181
AM		 10045 if (ivda.vda_name >= string_sec->sh_size)
10046 name = _("*invalid*");
10047 else
10048 name = strtab + ivda.vda_name;
252b5132 10049 nn += printf ("(%s%-*s",
16062207
ILT		 10050 name,
10051 12 - (int) strlen (name),
252b5132
RH		 10052 ")");
10053 }
10054 }
10055
10056 if (nn < 18)
10057 printf ("%*c", 18 - nn, ' ');
10058 }
10059
10060 putchar ('\n');
10061 }
10062
10063 free (data);
10064 free (strtab);
10065 free (symbols);
10066 }
10067 break;
103f02d3 10068
252b5132
RH		 10069 default:
10070 break;
10071 }
10072 }
10073
10074 if (! found)
10075 printf (_("\nNo version information found in this file.\n"));
10076
10077 return 1;
10078}
10079
d1133906 10080static const char *
d3ba0551 10081get_symbol_binding (unsigned int binding)
252b5132 10082{
b34976b6 10083 static char buff[32];
252b5132
RH		 10084
10085 switch (binding)
10086 {
b34976b6
AM		 10087 case STB_LOCAL: return "LOCAL";
10088 case STB_GLOBAL: return "GLOBAL";
10089 case STB_WEAK: return "WEAK";
252b5132
RH		 10090 default:
10091 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10092 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10093 binding);
252b5132 10094 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10095 {
10096 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10097 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10098 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10099 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10100 return "UNIQUE";
10101 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10102 }
252b5132 10103 else
e9e44622 10104 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10105 return buff;
10106 }
10107}
10108
d1133906 10109static const char *
d3ba0551 10110get_symbol_type (unsigned int type)
252b5132 10111{
b34976b6 10112 static char buff[32];
252b5132
RH		 10113
10114 switch (type)
10115 {
b34976b6
AM		 10116 case STT_NOTYPE: return "NOTYPE";
10117 case STT_OBJECT: return "OBJECT";
10118 case STT_FUNC: return "FUNC";
10119 case STT_SECTION: return "SECTION";
10120 case STT_FILE: return "FILE";
10121 case STT_COMMON: return "COMMON";
10122 case STT_TLS: return "TLS";
15ab5209
DB		 10123 case STT_RELC: return "RELC";
10124 case STT_SRELC: return "SRELC";
252b5132
RH		 10125 default:
10126 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10127 {
3510a7b8
NC		 10128 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10129 return "THUMB_FUNC";
103f02d3 10130
351b4b40 10131 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10132 return "REGISTER";
10133
10134 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10135 return "PARISC_MILLI";
10136
e9e44622 10137 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10138 }
252b5132 10139 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10140 {
10141 if (elf_header.e_machine == EM_PARISC)
10142 {
10143 if (type == STT_HP_OPAQUE)
10144 return "HP_OPAQUE";
10145 if (type == STT_HP_STUB)
10146 return "HP_STUB";
10147 }
10148
d8045f23 10149 if (type == STT_GNU_IFUNC
9c55345c 10150 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10151 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10152 /* GNU is still using the default value 0. */
d8045f23
NC		 10153 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10154 return "IFUNC";
10155
e9e44622 10156 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10157 }
252b5132 10158 else
e9e44622 10159 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10160 return buff;
10161 }
10162}
10163
d1133906 10164static const char *
d3ba0551 10165get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10166{
10167 switch (visibility)
10168 {
b34976b6
AM		 10169 case STV_DEFAULT: return "DEFAULT";
10170 case STV_INTERNAL: return "INTERNAL";
10171 case STV_HIDDEN: return "HIDDEN";
d1133906 10172 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10173 default:
10174 error (_("Unrecognized visibility value: %u"), visibility);
10175 return _("<unknown>");
d1133906
NC		 10176 }
10177}
10178
5e2b0d47
NC		 10179static const char *
10180get_mips_symbol_other (unsigned int other)
10181{
10182 switch (other)
10183 {
df58fc94
RS		 10184 case STO_OPTIONAL:
10185 return "OPTIONAL";
10186 case STO_MIPS_PLT:
10187 return "MIPS PLT";
10188 case STO_MIPS_PIC:
10189 return "MIPS PIC";
10190 case STO_MICROMIPS:
10191 return "MICROMIPS";
10192 case STO_MICROMIPS | STO_MIPS_PIC:
10193 return "MICROMIPS, MIPS PIC";
10194 case STO_MIPS16:
10195 return "MIPS16";
10196 default:
10197 return NULL;
5e2b0d47
NC		 10198 }
10199}
10200
28f997cf
TG		 10201static const char *
10202get_ia64_symbol_other (unsigned int other)
10203{
10204 if (is_ia64_vms ())
10205 {
10206 static char res[32];
10207
10208 res[0] = 0;
10209
10210 /* Function types is for images and .STB files only. */
10211 switch (elf_header.e_type)
10212 {
10213 case ET_DYN:
10214 case ET_EXEC:
10215 switch (VMS_ST_FUNC_TYPE (other))
10216 {
10217 case VMS_SFT_CODE_ADDR:
10218 strcat (res, " CA");
10219 break;
10220 case VMS_SFT_SYMV_IDX:
10221 strcat (res, " VEC");
10222 break;
10223 case VMS_SFT_FD:
10224 strcat (res, " FD");
10225 break;
10226 case VMS_SFT_RESERVE:
10227 strcat (res, " RSV");
10228 break;
10229 default:
bee0ee85
NC		 10230 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10231 VMS_ST_FUNC_TYPE (other));
10232 strcat (res, " <unknown>");
10233 break;
28f997cf
TG		 10234 }
10235 break;
10236 default:
10237 break;
10238 }
10239 switch (VMS_ST_LINKAGE (other))
10240 {
10241 case VMS_STL_IGNORE:
10242 strcat (res, " IGN");
10243 break;
10244 case VMS_STL_RESERVE:
10245 strcat (res, " RSV");
10246 break;
10247 case VMS_STL_STD:
10248 strcat (res, " STD");
10249 break;
10250 case VMS_STL_LNK:
10251 strcat (res, " LNK");
10252 break;
10253 default:
bee0ee85
NC		 10254 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10255 VMS_ST_LINKAGE (other));
10256 strcat (res, " <unknown>");
10257 break;
28f997cf
TG		 10258 }
10259
10260 if (res[0] != 0)
10261 return res + 1;
10262 else
10263 return res;
10264 }
10265 return NULL;
10266}
10267
6911b7dc
AM		 10268static const char *
10269get_ppc64_symbol_other (unsigned int other)
10270{
10271 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10272 {
10273 static char buf[32];
10274 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10275 PPC64_LOCAL_ENTRY_OFFSET (other));
10276 return buf;
10277 }
10278 return NULL;
10279}
10280
5e2b0d47
NC		 10281static const char *
10282get_symbol_other (unsigned int other)
10283{
10284 const char * result = NULL;
10285 static char buff [32];
10286
10287 if (other == 0)
10288 return "";
10289
10290 switch (elf_header.e_machine)
10291 {
10292 case EM_MIPS:
10293 result = get_mips_symbol_other (other);
28f997cf
TG		 10294 break;
10295 case EM_IA_64:
10296 result = get_ia64_symbol_other (other);
10297 break;
6911b7dc
AM		 10298 case EM_PPC64:
10299 result = get_ppc64_symbol_other (other);
10300 break;
5e2b0d47
NC		 10301 default:
10302 break;
10303 }
10304
10305 if (result)
10306 return result;
10307
10308 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10309 return buff;
10310}
10311
d1133906 10312static const char *
d3ba0551 10313get_symbol_index_type (unsigned int type)
252b5132 10314{
b34976b6 10315 static char buff[32];
5cf1065c 10316
252b5132
RH		 10317 switch (type)
10318 {
b34976b6
AM		 10319 case SHN_UNDEF: return "UND";
10320 case SHN_ABS: return "ABS";
10321 case SHN_COMMON: return "COM";
252b5132 10322 default:
9ce701e2
L		 10323 if (type == SHN_IA_64_ANSI_COMMON
10324 && elf_header.e_machine == EM_IA_64
10325 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10326 return "ANSI_COM";
8a9036a4 10327 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10328 || elf_header.e_machine == EM_L1OM
10329 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10330 && type == SHN_X86_64_LCOMMON)
10331 return "LARGE_COM";
ac145307
BS		 10332 else if ((type == SHN_MIPS_SCOMMON
10333 && elf_header.e_machine == EM_MIPS)
10334 || (type == SHN_TIC6X_SCOMMON
10335 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10336 return "SCOM";
10337 else if (type == SHN_MIPS_SUNDEFINED
10338 && elf_header.e_machine == EM_MIPS)
10339 return "SUND";
9ce701e2 10340 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10341 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10342 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10343 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10344 else if (type >= SHN_LORESERVE)
10345 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10346 else if (type >= elf_header.e_shnum)
e0a31db1 10347 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10348 else
232e7cb8 10349 sprintf (buff, "%3d", type);
5cf1065c 10350 break;
252b5132 10351 }
5cf1065c
NC		 10352
10353 return buff;
252b5132
RH		 10354}
10355
66543521 10356static bfd_vma *
57028622 10357get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10358{
2cf0635d
NC		 10359 unsigned char * e_data;
10360 bfd_vma * i_data;
252b5132 10361
57028622
NC		 10362 /* If the size_t type is smaller than the bfd_size_type, eg because
10363 you are building a 32-bit tool on a 64-bit host, then make sure
10364 that when (number) is cast to (size_t) no information is lost. */
10365 if (sizeof (size_t) < sizeof (bfd_size_type)
10366 && (bfd_size_type) ((size_t) number) != number)
10367 {
10368 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10369 (unsigned long long) number, ent_size);
10370 return NULL;
10371 }
948f632f 10372
3102e897
NC		 10373 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10374 attempting to allocate memory when the read is bound to fail. */
10375 if (ent_size * number > current_file_size)
10376 {
57028622
NC		 10377 error (_("Invalid number of dynamic entries: %llu\n"),
10378 (unsigned long long) number);
3102e897
NC		 10379 return NULL;
10380 }
10381
57028622 10382 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10383 if (e_data == NULL)
10384 {
57028622
NC		 10385 error (_("Out of memory reading %llu dynamic entries\n"),
10386 (unsigned long long) number);
252b5132
RH		 10387 return NULL;
10388 }
10389
57028622 10390 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10391 {
57028622
NC		 10392 error (_("Unable to read in %llu bytes of dynamic data\n"),
10393 (unsigned long long) (number * ent_size));
3102e897 10394 free (e_data);
252b5132
RH		 10395 return NULL;
10396 }
10397
57028622 10398 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10399 if (i_data == NULL)
10400 {
57028622
NC		 10401 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10402 (unsigned long long) number);
252b5132
RH		 10403 free (e_data);
10404 return NULL;
10405 }
10406
10407 while (number--)
66543521 10408 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10409
10410 free (e_data);
10411
10412 return i_data;
10413}
10414
6bd1a22c
L		 10415static void
10416print_dynamic_symbol (bfd_vma si, unsigned long hn)
10417{
2cf0635d 10418 Elf_Internal_Sym * psym;
6bd1a22c
L		 10419 int n;
10420
6bd1a22c
L		 10421 n = print_vma (si, DEC_5);
10422 if (n < 5)
0b4362b0 10423 fputs (&" "[n], stdout);
6bd1a22c 10424 printf (" %3lu: ", hn);
e0a31db1
NC		 10425
10426 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10427 {
3102e897
NC		 10428 printf (_("<No info available for dynamic symbol number %lu>\n"),
10429 (unsigned long) si);
e0a31db1
NC		 10430 return;
10431 }
10432
10433 psym = dynamic_symbols + si;
6bd1a22c
L		 10434 print_vma (psym->st_value, LONG_HEX);
10435 putchar (' ');
10436 print_vma (psym->st_size, DEC_5);
10437
f4be36b3
AM		 10438 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10439 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10440 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6bd1a22c
L		 10441 /* Check to see if any other bits in the st_other field are set.
10442 Note - displaying this information disrupts the layout of the
10443 table being generated, but for the moment this case is very
10444 rare. */
10445 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10446 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10447 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10448 if (VALID_DYNAMIC_NAME (psym->st_name))
10449 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10450 else
2b692964 10451 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10452 putchar ('\n');
10453}
10454
bb4d2ac2
L		 10455static const char *
10456get_symbol_version_string (FILE *file, int is_dynsym,
10457 const char *strtab,
10458 unsigned long int strtab_size,
10459 unsigned int si, Elf_Internal_Sym *psym,
10460 enum versioned_symbol_info *sym_info,
10461 unsigned short *vna_other)
10462{
10463 const char *version_string = NULL;
10464
10465 if (is_dynsym
10466 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10467 {
10468 unsigned char data[2];
10469 unsigned short vers_data;
10470 unsigned long offset;
10471 int is_nobits;
10472 int check_def;
10473
10474 offset = offset_from_vma
10475 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10476 sizeof data + si * sizeof (vers_data));
10477
10478 if (get_data (&data, file, offset + si * sizeof (vers_data),
10479 sizeof (data), 1, _("version data")) == NULL)
10480 return NULL;
10481
10482 vers_data = byte_get (data, 2);
10483
53774b7e
NC		 10484 is_nobits = (section_headers != NULL
10485 && psym->st_shndx < elf_header.e_shnum
bb4d2ac2
L		 10486 && section_headers[psym->st_shndx].sh_type
10487 == SHT_NOBITS);
10488
10489 check_def = (psym->st_shndx != SHN_UNDEF);
10490
10491 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10492 {
10493 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10494 && (is_nobits || ! check_def))
10495 {
10496 Elf_External_Verneed evn;
10497 Elf_Internal_Verneed ivn;
10498 Elf_Internal_Vernaux ivna;
10499
10500 /* We must test both. */
10501 offset = offset_from_vma
10502 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10503 sizeof evn);
10504
10505 do
10506 {
10507 unsigned long vna_off;
10508
10509 if (get_data (&evn, file, offset, sizeof (evn), 1,
10510 _("version need")) == NULL)
10511 {
10512 ivna.vna_next = 0;
10513 ivna.vna_other = 0;
10514 ivna.vna_name = 0;
10515 break;
10516 }
10517
10518 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10519 ivn.vn_next = BYTE_GET (evn.vn_next);
10520
10521 vna_off = offset + ivn.vn_aux;
10522
10523 do
10524 {
10525 Elf_External_Vernaux evna;
10526
10527 if (get_data (&evna, file, vna_off,
10528 sizeof (evna), 1,
10529 _("version need aux (3)")) == NULL)
10530 {
10531 ivna.vna_next = 0;
10532 ivna.vna_other = 0;
10533 ivna.vna_name = 0;
10534 }
10535 else
10536 {
10537 ivna.vna_other = BYTE_GET (evna.vna_other);
10538 ivna.vna_next = BYTE_GET (evna.vna_next);
10539 ivna.vna_name = BYTE_GET (evna.vna_name);
10540 }
10541
10542 vna_off += ivna.vna_next;
10543 }
10544 while (ivna.vna_other != vers_data
10545 && ivna.vna_next != 0);
10546
10547 if (ivna.vna_other == vers_data)
10548 break;
10549
10550 offset += ivn.vn_next;
10551 }
10552 while (ivn.vn_next != 0);
10553
10554 if (ivna.vna_other == vers_data)
10555 {
10556 *sym_info = symbol_undefined;
10557 *vna_other = ivna.vna_other;
10558 version_string = (ivna.vna_name < strtab_size
10559 ? strtab + ivna.vna_name
10560 : _("<corrupt>"));
10561 check_def = 0;
10562 }
10563 else if (! is_nobits)
10564 error (_("bad dynamic symbol\n"));
10565 else
10566 check_def = 1;
10567 }
10568
10569 if (check_def)
10570 {
10571 if (vers_data != 0x8001
10572 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10573 {
10574 Elf_Internal_Verdef ivd;
10575 Elf_Internal_Verdaux ivda;
10576 Elf_External_Verdaux evda;
10577 unsigned long off;
10578
10579 off = offset_from_vma
10580 (file,
10581 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10582 sizeof (Elf_External_Verdef));
10583
10584 do
10585 {
10586 Elf_External_Verdef evd;
10587
10588 if (get_data (&evd, file, off, sizeof (evd),
10589 1, _("version def")) == NULL)
10590 {
10591 ivd.vd_ndx = 0;
10592 ivd.vd_aux = 0;
10593 ivd.vd_next = 0;
10594 }
10595 else
10596 {
10597 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10598 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10599 ivd.vd_next = BYTE_GET (evd.vd_next);
10600 }
10601
10602 off += ivd.vd_next;
10603 }
10604 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10605 && ivd.vd_next != 0);
10606
10607 off -= ivd.vd_next;
10608 off += ivd.vd_aux;
10609
10610 if (get_data (&evda, file, off, sizeof (evda),
10611 1, _("version def aux")) == NULL)
10612 return version_string;
10613
10614 ivda.vda_name = BYTE_GET (evda.vda_name);
10615
10616 if (psym->st_name != ivda.vda_name)
10617 {
10618 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10619 ? symbol_hidden : symbol_public);
10620 version_string = (ivda.vda_name < strtab_size
10621 ? strtab + ivda.vda_name
10622 : _("<corrupt>"));
10623 }
10624 }
10625 }
10626 }
10627 }
10628 return version_string;
10629}
10630
e3c8793a 10631/* Dump the symbol table. */
252b5132 10632static int
2cf0635d 10633process_symbol_table (FILE * file)
252b5132 10634{
2cf0635d 10635 Elf_Internal_Shdr * section;
8b73c356
NC		 10636 bfd_size_type nbuckets = 0;
10637 bfd_size_type nchains = 0;
2cf0635d
NC		 10638 bfd_vma * buckets = NULL;
10639 bfd_vma * chains = NULL;
fdc90cb4 10640 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10641 bfd_vma * gnubuckets = NULL;
10642 bfd_vma * gnuchains = NULL;
6bd1a22c 10643 bfd_vma gnusymidx = 0;
071436c6 10644 bfd_size_type ngnuchains = 0;
252b5132 10645
2c610e4b 10646 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10647 return 1;
10648
6bd1a22c
L		 10649 if (dynamic_info[DT_HASH]
10650 && (do_histogram
2c610e4b
L		 10651 || (do_using_dynamic
10652 && !do_dyn_syms
10653 && dynamic_strings != NULL)))
252b5132 10654 {
66543521
AM		 10655 unsigned char nb[8];
10656 unsigned char nc[8];
8b73c356 10657 unsigned int hash_ent_size = 4;
66543521
AM		 10658
10659 if ((elf_header.e_machine == EM_ALPHA
10660 || elf_header.e_machine == EM_S390
10661 || elf_header.e_machine == EM_S390_OLD)
10662 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10663 hash_ent_size = 8;
10664
fb52b2f4
NC		 10665 if (fseek (file,
10666 (archive_file_offset
10667 + offset_from_vma (file, dynamic_info[DT_HASH],
10668 sizeof nb + sizeof nc)),
d93f0186 10669 SEEK_SET))
252b5132 10670 {
591a748a 10671 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10672 goto no_hash;
252b5132
RH		 10673 }
10674
66543521 10675 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10676 {
10677 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10678 goto no_hash;
252b5132
RH		 10679 }
10680
66543521 10681 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10682 {
10683 error (_("Failed to read in number of chains\n"));
d3a44ec6 10684 goto no_hash;
252b5132
RH		 10685 }
10686
66543521
AM		 10687 nbuckets = byte_get (nb, hash_ent_size);
10688 nchains = byte_get (nc, hash_ent_size);
252b5132 10689
66543521
AM		 10690 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10691 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10692
d3a44ec6 10693 no_hash:
252b5132 10694 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10695 {
10696 if (do_using_dynamic)
10697 return 0;
10698 free (buckets);
10699 free (chains);
10700 buckets = NULL;
10701 chains = NULL;
10702 nbuckets = 0;
10703 nchains = 0;
10704 }
252b5132
RH		 10705 }
10706
6bd1a22c
L		 10707 if (dynamic_info_DT_GNU_HASH
10708 && (do_histogram
2c610e4b
L		 10709 || (do_using_dynamic
10710 && !do_dyn_syms
10711 && dynamic_strings != NULL)))
252b5132 10712 {
6bd1a22c
L		 10713 unsigned char nb[16];
10714 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10715 bfd_vma buckets_vma;
10716
10717 if (fseek (file,
10718 (archive_file_offset
10719 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10720 sizeof nb)),
10721 SEEK_SET))
10722 {
10723 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10724 goto no_gnu_hash;
6bd1a22c 10725 }
252b5132 10726
6bd1a22c
L		 10727 if (fread (nb, 16, 1, file) != 1)
10728 {
10729 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10730 goto no_gnu_hash;
6bd1a22c
L		 10731 }
10732
10733 ngnubuckets = byte_get (nb, 4);
10734 gnusymidx = byte_get (nb + 4, 4);
10735 bitmaskwords = byte_get (nb + 8, 4);
10736 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10737 if (is_32bit_elf)
6bd1a22c 10738 buckets_vma += bitmaskwords * 4;
f7a99963 10739 else
6bd1a22c 10740 buckets_vma += bitmaskwords * 8;
252b5132 10741
6bd1a22c
L		 10742 if (fseek (file,
10743 (archive_file_offset
10744 + offset_from_vma (file, buckets_vma, 4)),
10745 SEEK_SET))
252b5132 10746 {
6bd1a22c 10747 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10748 goto no_gnu_hash;
6bd1a22c
L		 10749 }
10750
10751 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10752
6bd1a22c 10753 if (gnubuckets == NULL)
d3a44ec6 10754 goto no_gnu_hash;
6bd1a22c
L		 10755
10756 for (i = 0; i < ngnubuckets; i++)
10757 if (gnubuckets[i] != 0)
10758 {
10759 if (gnubuckets[i] < gnusymidx)
10760 return 0;
10761
10762 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10763 maxchain = gnubuckets[i];
10764 }
10765
10766 if (maxchain == 0xffffffff)
d3a44ec6 10767 goto no_gnu_hash;
6bd1a22c
L		 10768
10769 maxchain -= gnusymidx;
10770
10771 if (fseek (file,
10772 (archive_file_offset
10773 + offset_from_vma (file, buckets_vma
10774 + 4 * (ngnubuckets + maxchain), 4)),
10775 SEEK_SET))
10776 {
10777 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10778 goto no_gnu_hash;
6bd1a22c
L		 10779 }
10780
10781 do
10782 {
10783 if (fread (nb, 4, 1, file) != 1)
252b5132 10784 {
6bd1a22c 10785 error (_("Failed to determine last chain length\n"));
d3a44ec6 10786 goto no_gnu_hash;
6bd1a22c 10787 }
252b5132 10788
6bd1a22c 10789 if (maxchain + 1 == 0)
d3a44ec6 10790 goto no_gnu_hash;
252b5132 10791
6bd1a22c
L		 10792 ++maxchain;
10793 }
10794 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10795
6bd1a22c
L		 10796 if (fseek (file,
10797 (archive_file_offset
10798 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10799 SEEK_SET))
10800 {
10801 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10802 goto no_gnu_hash;
6bd1a22c
L		 10803 }
10804
10805 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10806 ngnuchains = maxchain;
6bd1a22c 10807
d3a44ec6 10808 no_gnu_hash:
6bd1a22c 10809 if (gnuchains == NULL)
d3a44ec6
JJ		 10810 {
10811 free (gnubuckets);
d3a44ec6
JJ		 10812 gnubuckets = NULL;
10813 ngnubuckets = 0;
f64fddf1
NC		 10814 if (do_using_dynamic)
10815 return 0;
d3a44ec6 10816 }
6bd1a22c
L		 10817 }
10818
10819 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10820 && do_syms
10821 && do_using_dynamic
3102e897
NC		 10822 && dynamic_strings != NULL
10823 && dynamic_symbols != NULL)
6bd1a22c
L		 10824 {
10825 unsigned long hn;
10826
10827 if (dynamic_info[DT_HASH])
10828 {
10829 bfd_vma si;
10830
10831 printf (_("\nSymbol table for image:\n"));
10832 if (is_32bit_elf)
10833 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10834 else
10835 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10836
10837 for (hn = 0; hn < nbuckets; hn++)
10838 {
10839 if (! buckets[hn])
10840 continue;
10841
10842 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10843 print_dynamic_symbol (si, hn);
252b5132
RH		 10844 }
10845 }
6bd1a22c
L		 10846
10847 if (dynamic_info_DT_GNU_HASH)
10848 {
10849 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10850 if (is_32bit_elf)
10851 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10852 else
10853 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10854
10855 for (hn = 0; hn < ngnubuckets; ++hn)
10856 if (gnubuckets[hn] != 0)
10857 {
10858 bfd_vma si = gnubuckets[hn];
10859 bfd_vma off = si - gnusymidx;
10860
10861 do
10862 {
10863 print_dynamic_symbol (si, hn);
10864 si++;
10865 }
071436c6 10866 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10867 }
10868 }
252b5132 10869 }
8b73c356
NC		 10870 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10871 && section_headers != NULL)
252b5132 10872 {
b34976b6 10873 unsigned int i;
252b5132
RH		 10874
10875 for (i = 0, section = section_headers;
10876 i < elf_header.e_shnum;
10877 i++, section++)
10878 {
b34976b6 10879 unsigned int si;
2cf0635d 10880 char * strtab = NULL;
c256ffe7 10881 unsigned long int strtab_size = 0;
2cf0635d
NC		 10882 Elf_Internal_Sym * symtab;
10883 Elf_Internal_Sym * psym;
ba5cdace 10884 unsigned long num_syms;
252b5132 10885
2c610e4b
L		 10886 if ((section->sh_type != SHT_SYMTAB
10887 && section->sh_type != SHT_DYNSYM)
10888 || (!do_syms
10889 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 10890 continue;
10891
dd24e3da
NC		 10892 if (section->sh_entsize == 0)
10893 {
10894 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 10895 printable_section_name (section));
dd24e3da
NC		 10896 continue;
10897 }
10898
252b5132 10899 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 10900 printable_section_name (section),
252b5132 10901 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 10902
f7a99963 10903 if (is_32bit_elf)
ca47b30c 10904 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 10905 else
ca47b30c 10906 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 10907
ba5cdace 10908 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 10909 if (symtab == NULL)
10910 continue;
10911
10912 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 10913 {
10914 strtab = string_table;
10915 strtab_size = string_table_length;
10916 }
4fbb74a6 10917 else if (section->sh_link < elf_header.e_shnum)
252b5132 10918 {
2cf0635d 10919 Elf_Internal_Shdr * string_sec;
252b5132 10920
4fbb74a6 10921 string_sec = section_headers + section->sh_link;
252b5132 10922
3f5e193b
NC		 10923 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10924 1, string_sec->sh_size,
10925 _("string table"));
c256ffe7 10926 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 10927 }
10928
ba5cdace 10929 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 10930 {
bb4d2ac2
L		 10931 const char *version_string;
10932 enum versioned_symbol_info sym_info;
10933 unsigned short vna_other;
10934
5e220199 10935 printf ("%6d: ", si);
f7a99963
NC		 10936 print_vma (psym->st_value, LONG_HEX);
10937 putchar (' ');
10938 print_vma (psym->st_size, DEC_5);
d1133906
NC		 10939 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10940 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
f4be36b3 10941 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5e2b0d47
NC		 10942 /* Check to see if any other bits in the st_other field are set.
10943 Note - displaying this information disrupts the layout of the
10944 table being generated, but for the moment this case is very rare. */
10945 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10946 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
31104126 10947 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 10948 print_symbol (25, psym->st_name < strtab_size
2b692964 10949 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 10950
bb4d2ac2
L		 10951 version_string
10952 = get_symbol_version_string (file,
10953 section->sh_type == SHT_DYNSYM,
10954 strtab, strtab_size, si,
10955 psym, &sym_info, &vna_other);
10956 if (version_string)
252b5132 10957 {
bb4d2ac2
L		 10958 if (sym_info == symbol_undefined)
10959 printf ("@%s (%d)", version_string, vna_other);
10960 else
10961 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10962 version_string);
252b5132
RH		 10963 }
10964
10965 putchar ('\n');
10966 }
10967
10968 free (symtab);
10969 if (strtab != string_table)
10970 free (strtab);
10971 }
10972 }
10973 else if (do_syms)
10974 printf
10975 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10976
10977 if (do_histogram && buckets != NULL)
10978 {
2cf0635d
NC		 10979 unsigned long * lengths;
10980 unsigned long * counts;
66543521
AM		 10981 unsigned long hn;
10982 bfd_vma si;
10983 unsigned long maxlength = 0;
10984 unsigned long nzero_counts = 0;
10985 unsigned long nsyms = 0;
94d15024 10986 unsigned long chained;
252b5132 10987
66543521
AM		 10988 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10989 (unsigned long) nbuckets);
252b5132 10990
3f5e193b 10991 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 10992 if (lengths == NULL)
10993 {
8b73c356 10994 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 10995 return 0;
10996 }
8b73c356
NC		 10997
10998 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 10999 for (hn = 0; hn < nbuckets; ++hn)
11000 {
94d15024
MF		 11001 for (si = buckets[hn], chained = 0;
11002 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11003 si = chains[si], ++chained)
252b5132 11004 {
b34976b6 11005 ++nsyms;
252b5132 11006 if (maxlength < ++lengths[hn])
b34976b6 11007 ++maxlength;
252b5132 11008 }
94d15024
MF		 11009
11010 /* PR binutils/17531: A corrupt binary could contain broken
11011 histogram data. Do not go into an infinite loop trying
11012 to process it. */
11013 if (chained > nchains)
11014 {
11015 error (_("histogram chain is corrupt\n"));
11016 break;
11017 }
252b5132
RH		 11018 }
11019
3f5e193b 11020 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11021 if (counts == NULL)
11022 {
b2e951ec 11023 free (lengths);
8b73c356 11024 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11025 return 0;
11026 }
11027
11028 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11029 ++counts[lengths[hn]];
252b5132 11030
103f02d3 11031 if (nbuckets > 0)
252b5132 11032 {
66543521
AM		 11033 unsigned long i;
11034 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11035 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11036 for (i = 1; i <= maxlength; ++i)
103f02d3 11037 {
66543521
AM		 11038 nzero_counts += counts[i] * i;
11039 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11040 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11041 (nzero_counts * 100.0) / nsyms);
11042 }
252b5132
RH		 11043 }
11044
11045 free (counts);
11046 free (lengths);
11047 }
11048
11049 if (buckets != NULL)
11050 {
11051 free (buckets);
11052 free (chains);
11053 }
11054
d3a44ec6 11055 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11056 {
2cf0635d
NC		 11057 unsigned long * lengths;
11058 unsigned long * counts;
fdc90cb4
JJ		 11059 unsigned long hn;
11060 unsigned long maxlength = 0;
11061 unsigned long nzero_counts = 0;
11062 unsigned long nsyms = 0;
fdc90cb4 11063
8b73c356
NC		 11064 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11065 (unsigned long) ngnubuckets);
11066
3f5e193b 11067 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11068 if (lengths == NULL)
11069 {
8b73c356 11070 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11071 return 0;
11072 }
11073
fdc90cb4
JJ		 11074 printf (_(" Length Number %% of total Coverage\n"));
11075
11076 for (hn = 0; hn < ngnubuckets; ++hn)
11077 if (gnubuckets[hn] != 0)
11078 {
11079 bfd_vma off, length = 1;
11080
6bd1a22c 11081 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11082 /* PR 17531 file: 010-77222-0.004. */
11083 off < ngnuchains && (gnuchains[off] & 1) == 0;
11084 ++off)
fdc90cb4
JJ		 11085 ++length;
11086 lengths[hn] = length;
11087 if (length > maxlength)
11088 maxlength = length;
11089 nsyms += length;
11090 }
11091
3f5e193b 11092 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11093 if (counts == NULL)
11094 {
b2e951ec 11095 free (lengths);
8b73c356 11096 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11097 return 0;
11098 }
11099
11100 for (hn = 0; hn < ngnubuckets; ++hn)
11101 ++counts[lengths[hn]];
11102
11103 if (ngnubuckets > 0)
11104 {
11105 unsigned long j;
11106 printf (" 0 %-10lu (%5.1f%%)\n",
11107 counts[0], (counts[0] * 100.0) / ngnubuckets);
11108 for (j = 1; j <= maxlength; ++j)
11109 {
11110 nzero_counts += counts[j] * j;
11111 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11112 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11113 (nzero_counts * 100.0) / nsyms);
11114 }
11115 }
11116
11117 free (counts);
11118 free (lengths);
11119 free (gnubuckets);
11120 free (gnuchains);
11121 }
11122
252b5132
RH		 11123 return 1;
11124}
11125
11126static int
2cf0635d 11127process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11128{
b4c96d0d 11129 unsigned int i;
252b5132
RH		 11130
11131 if (dynamic_syminfo == NULL
11132 || !do_dynamic)
11133 /* No syminfo, this is ok. */
11134 return 1;
11135
11136 /* There better should be a dynamic symbol section. */
11137 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11138 return 0;
11139
11140 if (dynamic_addr)
11141 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11142 dynamic_syminfo_offset, dynamic_syminfo_nent);
11143
11144 printf (_(" Num: Name BoundTo Flags\n"));
11145 for (i = 0; i < dynamic_syminfo_nent; ++i)
11146 {
11147 unsigned short int flags = dynamic_syminfo[i].si_flags;
11148
31104126 11149 printf ("%4d: ", i);
4082ef84
NC		 11150 if (i >= num_dynamic_syms)
11151 printf (_("<corrupt index>"));
11152 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11153 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11154 else
2b692964 11155 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11156 putchar (' ');
252b5132
RH		 11157
11158 switch (dynamic_syminfo[i].si_boundto)
11159 {
11160 case SYMINFO_BT_SELF:
11161 fputs ("SELF ", stdout);
11162 break;
11163 case SYMINFO_BT_PARENT:
11164 fputs ("PARENT ", stdout);
11165 break;
11166 default:
11167 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11168 && dynamic_syminfo[i].si_boundto < dynamic_nent
11169 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11170 {
d79b3d50 11171 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11172 putchar (' ' );
11173 }
252b5132
RH		 11174 else
11175 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11176 break;
11177 }
11178
11179 if (flags & SYMINFO_FLG_DIRECT)
11180 printf (" DIRECT");
11181 if (flags & SYMINFO_FLG_PASSTHRU)
11182 printf (" PASSTHRU");
11183 if (flags & SYMINFO_FLG_COPY)
11184 printf (" COPY");
11185 if (flags & SYMINFO_FLG_LAZYLOAD)
11186 printf (" LAZYLOAD");
11187
11188 puts ("");
11189 }
11190
11191 return 1;
11192}
11193
cf13d699
NC		 11194/* Check to see if the given reloc needs to be handled in a target specific
11195 manner. If so then process the reloc and return TRUE otherwise return
11196 FALSE. */
09c11c86 11197
cf13d699
NC		 11198static bfd_boolean
11199target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11200 unsigned char * start,
11201 Elf_Internal_Sym * symtab)
252b5132 11202{
cf13d699 11203 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11204
cf13d699 11205 switch (elf_header.e_machine)
252b5132 11206 {
13761a11
NC		 11207 case EM_MSP430:
11208 case EM_MSP430_OLD:
11209 {
11210 static Elf_Internal_Sym * saved_sym = NULL;
11211
11212 switch (reloc_type)
11213 {
11214 case 10: /* R_MSP430_SYM_DIFF */
11215 if (uses_msp430x_relocs ())
11216 break;
11217 case 21: /* R_MSP430X_SYM_DIFF */
11218 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11219 return TRUE;
11220
11221 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11222 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11223 goto handle_sym_diff;
0b4362b0 11224
13761a11
NC		 11225 case 5: /* R_MSP430_16_BYTE */
11226 case 9: /* R_MSP430_8 */
11227 if (uses_msp430x_relocs ())
11228 break;
11229 goto handle_sym_diff;
11230
11231 case 2: /* R_MSP430_ABS16 */
11232 case 15: /* R_MSP430X_ABS16 */
11233 if (! uses_msp430x_relocs ())
11234 break;
11235 goto handle_sym_diff;
0b4362b0 11236
13761a11
NC		 11237 handle_sym_diff:
11238 if (saved_sym != NULL)
11239 {
11240 bfd_vma value;
11241
11242 value = reloc->r_addend
11243 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11244 - saved_sym->st_value);
11245
11246 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11247
11248 saved_sym = NULL;
11249 return TRUE;
11250 }
11251 break;
11252
11253 default:
11254 if (saved_sym != NULL)
071436c6 11255 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11256 break;
11257 }
11258 break;
11259 }
11260
cf13d699
NC		 11261 case EM_MN10300:
11262 case EM_CYGNUS_MN10300:
11263 {
11264 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11265
cf13d699
NC		 11266 switch (reloc_type)
11267 {
11268 case 34: /* R_MN10300_ALIGN */
11269 return TRUE;
11270 case 33: /* R_MN10300_SYM_DIFF */
11271 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11272 return TRUE;
11273 case 1: /* R_MN10300_32 */
11274 case 2: /* R_MN10300_16 */
11275 if (saved_sym != NULL)
11276 {
11277 bfd_vma value;
252b5132 11278
cf13d699
NC		 11279 value = reloc->r_addend
11280 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11281 - saved_sym->st_value);
252b5132 11282
cf13d699 11283 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11284
cf13d699
NC		 11285 saved_sym = NULL;
11286 return TRUE;
11287 }
11288 break;
11289 default:
11290 if (saved_sym != NULL)
071436c6 11291 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11292 break;
11293 }
11294 break;
11295 }
6ff71e76
NC		 11296
11297 case EM_RL78:
11298 {
11299 static bfd_vma saved_sym1 = 0;
11300 static bfd_vma saved_sym2 = 0;
11301 static bfd_vma value;
11302
11303 switch (reloc_type)
11304 {
11305 case 0x80: /* R_RL78_SYM. */
11306 saved_sym1 = saved_sym2;
11307 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11308 saved_sym2 += reloc->r_addend;
11309 return TRUE;
11310
11311 case 0x83: /* R_RL78_OPsub. */
11312 value = saved_sym1 - saved_sym2;
11313 saved_sym2 = saved_sym1 = 0;
11314 return TRUE;
11315 break;
11316
11317 case 0x41: /* R_RL78_ABS32. */
11318 byte_put (start + reloc->r_offset, value, 4);
11319 value = 0;
11320 return TRUE;
11321
11322 case 0x43: /* R_RL78_ABS16. */
11323 byte_put (start + reloc->r_offset, value, 2);
11324 value = 0;
11325 return TRUE;
11326
11327 default:
11328 break;
11329 }
11330 break;
11331 }
252b5132
RH		 11332 }
11333
cf13d699 11334 return FALSE;
252b5132
RH		 11335}
11336
aca88567
NC		 11337/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11338 DWARF debug sections. This is a target specific test. Note - we do not
11339 go through the whole including-target-headers-multiple-times route, (as
11340 we have already done with <elf/h8.h>) because this would become very
11341 messy and even then this function would have to contain target specific
11342 information (the names of the relocs instead of their numeric values).
11343 FIXME: This is not the correct way to solve this problem. The proper way
11344 is to have target specific reloc sizing and typing functions created by
11345 the reloc-macros.h header, in the same way that it already creates the
11346 reloc naming functions. */
11347
11348static bfd_boolean
11349is_32bit_abs_reloc (unsigned int reloc_type)
11350{
11351 switch (elf_header.e_machine)
11352 {
41e92641 11353 case EM_386:
22abe556 11354 case EM_IAMCU:
41e92641 11355 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11356 case EM_68K:
11357 return reloc_type == 1; /* R_68K_32. */
11358 case EM_860:
11359 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11360 case EM_960:
11361 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11362 case EM_AARCH64:
11363 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11364 case EM_ALPHA:
137b6b5f 11365 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11366 case EM_ARC:
11367 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11368 case EM_ARC_COMPACT:
11369 case EM_ARC_COMPACT2:
11370 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11371 case EM_ARM:
11372 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11373 case EM_AVR_OLD:
aca88567
NC		 11374 case EM_AVR:
11375 return reloc_type == 1;
cfb8c092
NC		 11376 case EM_ADAPTEVA_EPIPHANY:
11377 return reloc_type == 3;
aca88567
NC		 11378 case EM_BLACKFIN:
11379 return reloc_type == 0x12; /* R_byte4_data. */
11380 case EM_CRIS:
11381 return reloc_type == 3; /* R_CRIS_32. */
11382 case EM_CR16:
11383 return reloc_type == 3; /* R_CR16_NUM32. */
11384 case EM_CRX:
11385 return reloc_type == 15; /* R_CRX_NUM32. */
11386 case EM_CYGNUS_FRV:
11387 return reloc_type == 1;
41e92641
NC		 11388 case EM_CYGNUS_D10V:
11389 case EM_D10V:
11390 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11391 case EM_CYGNUS_D30V:
11392 case EM_D30V:
11393 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11394 case EM_DLX:
11395 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11396 case EM_CYGNUS_FR30:
11397 case EM_FR30:
11398 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11399 case EM_FT32:
11400 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11401 case EM_H8S:
11402 case EM_H8_300:
11403 case EM_H8_300H:
11404 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11405 case EM_IA_64:
d1c4b12b
NC		 11406 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11407 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11408 case EM_IP2K_OLD:
11409 case EM_IP2K:
11410 return reloc_type == 2; /* R_IP2K_32. */
11411 case EM_IQ2000:
11412 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11413 case EM_LATTICEMICO32:
11414 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11415 case EM_M32C_OLD:
aca88567
NC		 11416 case EM_M32C:
11417 return reloc_type == 3; /* R_M32C_32. */
11418 case EM_M32R:
11419 return reloc_type == 34; /* R_M32R_32_RELA. */
11420 case EM_MCORE:
11421 return reloc_type == 1; /* R_MCORE_ADDR32. */
11422 case EM_CYGNUS_MEP:
11423 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11424 case EM_METAG:
11425 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11426 case EM_MICROBLAZE:
11427 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11428 case EM_MIPS:
11429 return reloc_type == 2; /* R_MIPS_32. */
11430 case EM_MMIX:
11431 return reloc_type == 4; /* R_MMIX_32. */
11432 case EM_CYGNUS_MN10200:
11433 case EM_MN10200:
11434 return reloc_type == 1; /* R_MN10200_32. */
11435 case EM_CYGNUS_MN10300:
11436 case EM_MN10300:
11437 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11438 case EM_MOXIE:
11439 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11440 case EM_MSP430_OLD:
11441 case EM_MSP430:
13761a11 11442 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11443 case EM_MT:
11444 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11445 case EM_NDS32:
11446 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11447 case EM_ALTERA_NIOS2:
36591ba1 11448 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11449 case EM_NIOS32:
11450 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11451 case EM_OR1K:
11452 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11453 case EM_PARISC:
5fda8eca
NC		 11454 return (reloc_type == 1 /* R_PARISC_DIR32. */
11455 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11456 case EM_PJ:
11457 case EM_PJ_OLD:
11458 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11459 case EM_PPC64:
11460 return reloc_type == 1; /* R_PPC64_ADDR32. */
11461 case EM_PPC:
11462 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11463 case EM_RL78:
11464 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11465 case EM_RX:
11466 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11467 case EM_S370:
11468 return reloc_type == 1; /* R_I370_ADDR31. */
11469 case EM_S390_OLD:
11470 case EM_S390:
11471 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11472 case EM_SCORE:
11473 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11474 case EM_SH:
11475 return reloc_type == 1; /* R_SH_DIR32. */
11476 case EM_SPARC32PLUS:
11477 case EM_SPARCV9:
11478 case EM_SPARC:
11479 return reloc_type == 3 /* R_SPARC_32. */
11480 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11481 case EM_SPU:
11482 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11483 case EM_TI_C6000:
11484 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11485 case EM_TILEGX:
11486 return reloc_type == 2; /* R_TILEGX_32. */
11487 case EM_TILEPRO:
11488 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11489 case EM_CYGNUS_V850:
11490 case EM_V850:
11491 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11492 case EM_V800:
11493 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11494 case EM_VAX:
11495 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11496 case EM_VISIUM:
11497 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11498 case EM_X86_64:
8a9036a4 11499 case EM_L1OM:
7a9068fe 11500 case EM_K1OM:
aca88567 11501 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11502 case EM_XC16X:
11503 case EM_C166:
11504 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11505 case EM_XGATE:
11506 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11507 case EM_XSTORMY16:
11508 return reloc_type == 1; /* R_XSTROMY16_32. */
11509 case EM_XTENSA_OLD:
11510 case EM_XTENSA:
11511 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11512 default:
bee0ee85
NC		 11513 {
11514 static unsigned int prev_warn = 0;
11515
11516 /* Avoid repeating the same warning multiple times. */
11517 if (prev_warn != elf_header.e_machine)
11518 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11519 elf_header.e_machine);
11520 prev_warn = elf_header.e_machine;
11521 return FALSE;
11522 }
aca88567
NC		 11523 }
11524}
11525
11526/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11527 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11528
11529static bfd_boolean
11530is_32bit_pcrel_reloc (unsigned int reloc_type)
11531{
11532 switch (elf_header.e_machine)
11533 {
41e92641 11534 case EM_386:
22abe556 11535 case EM_IAMCU:
3e0873ac 11536 return reloc_type == 2; /* R_386_PC32. */
aca88567 11537 case EM_68K:
3e0873ac 11538 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11539 case EM_AARCH64:
11540 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11541 case EM_ADAPTEVA_EPIPHANY:
11542 return reloc_type == 6;
aca88567
NC		 11543 case EM_ALPHA:
11544 return reloc_type == 10; /* R_ALPHA_SREL32. */
41e92641 11545 case EM_ARM:
3e0873ac 11546 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11547 case EM_MICROBLAZE:
11548 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11549 case EM_OR1K:
11550 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11551 case EM_PARISC:
85acf597 11552 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11553 case EM_PPC:
11554 return reloc_type == 26; /* R_PPC_REL32. */
11555 case EM_PPC64:
3e0873ac 11556 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11557 case EM_S390_OLD:
11558 case EM_S390:
3e0873ac 11559 return reloc_type == 5; /* R_390_PC32. */
aca88567 11560 case EM_SH:
3e0873ac 11561 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11562 case EM_SPARC32PLUS:
11563 case EM_SPARCV9:
11564 case EM_SPARC:
3e0873ac 11565 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11566 case EM_SPU:
11567 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11568 case EM_TILEGX:
11569 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11570 case EM_TILEPRO:
11571 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11572 case EM_VISIUM:
11573 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11574 case EM_X86_64:
8a9036a4 11575 case EM_L1OM:
7a9068fe 11576 case EM_K1OM:
3e0873ac 11577 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11578 case EM_XTENSA_OLD:
11579 case EM_XTENSA:
11580 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11581 default:
11582 /* Do not abort or issue an error message here. Not all targets use
11583 pc-relative 32-bit relocs in their DWARF debug information and we
11584 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11585 more helpful warning message will be generated by apply_relocations
11586 anyway, so just return. */
aca88567
NC		 11587 return FALSE;
11588 }
11589}
11590
11591/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11592 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11593
11594static bfd_boolean
11595is_64bit_abs_reloc (unsigned int reloc_type)
11596{
11597 switch (elf_header.e_machine)
11598 {
a06ea964
NC		 11599 case EM_AARCH64:
11600 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11601 case EM_ALPHA:
11602 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11603 case EM_IA_64:
11604 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11605 case EM_PARISC:
11606 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11607 case EM_PPC64:
11608 return reloc_type == 38; /* R_PPC64_ADDR64. */
11609 case EM_SPARC32PLUS:
11610 case EM_SPARCV9:
11611 case EM_SPARC:
11612 return reloc_type == 54; /* R_SPARC_UA64. */
11613 case EM_X86_64:
8a9036a4 11614 case EM_L1OM:
7a9068fe 11615 case EM_K1OM:
aca88567 11616 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11617 case EM_S390_OLD:
11618 case EM_S390:
aa137e4d
NC		 11619 return reloc_type == 22; /* R_S390_64. */
11620 case EM_TILEGX:
11621 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11622 case EM_MIPS:
aa137e4d 11623 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11624 default:
11625 return FALSE;
11626 }
11627}
11628
85acf597
RH		 11629/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11630 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11631
11632static bfd_boolean
11633is_64bit_pcrel_reloc (unsigned int reloc_type)
11634{
11635 switch (elf_header.e_machine)
11636 {
a06ea964
NC		 11637 case EM_AARCH64:
11638 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11639 case EM_ALPHA:
aa137e4d 11640 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11641 case EM_IA_64:
aa137e4d 11642 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11643 case EM_PARISC:
aa137e4d 11644 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11645 case EM_PPC64:
aa137e4d 11646 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11647 case EM_SPARC32PLUS:
11648 case EM_SPARCV9:
11649 case EM_SPARC:
aa137e4d 11650 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11651 case EM_X86_64:
8a9036a4 11652 case EM_L1OM:
7a9068fe 11653 case EM_K1OM:
aa137e4d 11654 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11655 case EM_S390_OLD:
11656 case EM_S390:
aa137e4d
NC		 11657 return reloc_type == 23; /* R_S390_PC64. */
11658 case EM_TILEGX:
11659 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11660 default:
11661 return FALSE;
11662 }
11663}
11664
4dc3c23d
AM		 11665/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11666 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11667
11668static bfd_boolean
11669is_24bit_abs_reloc (unsigned int reloc_type)
11670{
11671 switch (elf_header.e_machine)
11672 {
11673 case EM_CYGNUS_MN10200:
11674 case EM_MN10200:
11675 return reloc_type == 4; /* R_MN10200_24. */
11676 default:
11677 return FALSE;
11678 }
11679}
11680
aca88567
NC		 11681/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11682 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11683
11684static bfd_boolean
11685is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11686{
11687 switch (elf_header.e_machine)
11688 {
886a2506
NC		 11689 case EM_ARC:
11690 case EM_ARC_COMPACT:
11691 case EM_ARC_COMPACT2:
11692 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11693 case EM_AVR_OLD:
11694 case EM_AVR:
11695 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11696 case EM_ADAPTEVA_EPIPHANY:
11697 return reloc_type == 5;
41e92641
NC		 11698 case EM_CYGNUS_D10V:
11699 case EM_D10V:
11700 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11701 case EM_H8S:
11702 case EM_H8_300:
11703 case EM_H8_300H:
aca88567
NC		 11704 return reloc_type == R_H8_DIR16;
11705 case EM_IP2K_OLD:
11706 case EM_IP2K:
11707 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11708 case EM_M32C_OLD:
f4236fe4
DD		 11709 case EM_M32C:
11710 return reloc_type == 1; /* R_M32C_16 */
aca88567 11711 case EM_MSP430:
13761a11
NC		 11712 if (uses_msp430x_relocs ())
11713 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11714 case EM_MSP430_OLD:
aca88567 11715 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11716 case EM_NDS32:
11717 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11718 case EM_ALTERA_NIOS2:
36591ba1 11719 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11720 case EM_NIOS32:
11721 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11722 case EM_OR1K:
11723 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11724 case EM_TI_C6000:
11725 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11726 case EM_XC16X:
11727 case EM_C166:
11728 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11729 case EM_CYGNUS_MN10200:
11730 case EM_MN10200:
11731 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11732 case EM_CYGNUS_MN10300:
11733 case EM_MN10300:
11734 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11735 case EM_VISIUM:
11736 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11737 case EM_XGATE:
11738 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11739 default:
aca88567 11740 return FALSE;
4b78141a
NC		 11741 }
11742}
11743
2a7b2e88
JK		 11744/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11745 relocation entries (possibly formerly used for SHT_GROUP sections). */
11746
11747static bfd_boolean
11748is_none_reloc (unsigned int reloc_type)
11749{
11750 switch (elf_header.e_machine)
11751 {
cb8f3167
NC		 11752 case EM_68K: /* R_68K_NONE. */
11753 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11754 case EM_SPARC32PLUS:
11755 case EM_SPARCV9:
cb8f3167
NC		 11756 case EM_SPARC: /* R_SPARC_NONE. */
11757 case EM_MIPS: /* R_MIPS_NONE. */
11758 case EM_PARISC: /* R_PARISC_NONE. */
11759 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11760 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11761 case EM_PPC: /* R_PPC_NONE. */
11762 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11763 case EM_ARC: /* R_ARC_NONE. */
11764 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11765 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11766 case EM_ARM: /* R_ARM_NONE. */
11767 case EM_IA_64: /* R_IA64_NONE. */
11768 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11769 case EM_S390_OLD:
cb8f3167
NC		 11770 case EM_S390: /* R_390_NONE. */
11771 case EM_CRIS: /* R_CRIS_NONE. */
11772 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11773 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11774 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11775 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11776 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11777 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11778 case EM_M32R: /* R_M32R_NONE. */
40b36596 11779 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11780 case EM_TILEGX: /* R_TILEGX_NONE. */
11781 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11782 case EM_XC16X:
11783 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11784 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11785 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11786 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11787 return reloc_type == 0;
a06ea964
NC		 11788 case EM_AARCH64:
11789 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11790 case EM_NDS32:
11791 return (reloc_type == 0 /* R_XTENSA_NONE. */
11792 || reloc_type == 204 /* R_NDS32_DIFF8. */
11793 || reloc_type == 205 /* R_NDS32_DIFF16. */
11794 || reloc_type == 206 /* R_NDS32_DIFF32. */
11795 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11796 case EM_XTENSA_OLD:
11797 case EM_XTENSA:
4dc3c23d
AM		 11798 return (reloc_type == 0 /* R_XTENSA_NONE. */
11799 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11800 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11801 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11802 case EM_METAG:
11803 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11804 }
11805 return FALSE;
11806}
11807
d1c4b12b
NC		 11808/* Returns TRUE if there is a relocation against
11809 section NAME at OFFSET bytes. */
11810
11811bfd_boolean
11812reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11813{
11814 Elf_Internal_Rela * relocs;
11815 Elf_Internal_Rela * rp;
11816
11817 if (dsec == NULL || dsec->reloc_info == NULL)
11818 return FALSE;
11819
11820 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11821
11822 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11823 if (rp->r_offset == offset)
11824 return TRUE;
11825
11826 return FALSE;
11827}
11828
cf13d699
NC		 11829/* Apply relocations to a section.
11830 Note: So far support has been added only for those relocations
11831 which can be found in debug sections.
d1c4b12b
NC		 11832 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11833 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11834 FIXME: Add support for more relocations ? */
1b315056 11835
cf13d699 11836static void
d1c4b12b
NC		 11837apply_relocations (void * file,
11838 const Elf_Internal_Shdr * section,
11839 unsigned char * start,
11840 bfd_size_type size,
11841 void ** relocs_return,
11842 unsigned long * num_relocs_return)
1b315056 11843{
cf13d699 11844 Elf_Internal_Shdr * relsec;
0d2a7a93 11845 unsigned char * end = start + size;
cb8f3167 11846
d1c4b12b
NC		 11847 if (relocs_return != NULL)
11848 {
11849 * (Elf_Internal_Rela **) relocs_return = NULL;
11850 * num_relocs_return = 0;
11851 }
11852
cf13d699
NC		 11853 if (elf_header.e_type != ET_REL)
11854 return;
1b315056 11855
cf13d699 11856 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11857 for (relsec = section_headers;
11858 relsec < section_headers + elf_header.e_shnum;
11859 ++relsec)
252b5132 11860 {
41e92641
NC		 11861 bfd_boolean is_rela;
11862 unsigned long num_relocs;
2cf0635d
NC		 11863 Elf_Internal_Rela * relocs;
11864 Elf_Internal_Rela * rp;
11865 Elf_Internal_Shdr * symsec;
11866 Elf_Internal_Sym * symtab;
ba5cdace 11867 unsigned long num_syms;
2cf0635d 11868 Elf_Internal_Sym * sym;
252b5132 11869
41e92641 11870 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11871 || relsec->sh_info >= elf_header.e_shnum
11872 || section_headers + relsec->sh_info != section
c256ffe7 11873 || relsec->sh_size == 0
4fbb74a6 11874 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 11875 continue;
428409d5 11876
41e92641
NC		 11877 is_rela = relsec->sh_type == SHT_RELA;
11878
11879 if (is_rela)
11880 {
3f5e193b
NC		 11881 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11882 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11883 return;
11884 }
11885 else
11886 {
3f5e193b
NC		 11887 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11888 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 11889 return;
11890 }
11891
11892 /* SH uses RELA but uses in place value instead of the addend field. */
11893 if (elf_header.e_machine == EM_SH)
11894 is_rela = FALSE;
428409d5 11895
4fbb74a6 11896 symsec = section_headers + relsec->sh_link;
ba5cdace 11897 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 11898
41e92641 11899 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 11900 {
41e92641
NC		 11901 bfd_vma addend;
11902 unsigned int reloc_type;
11903 unsigned int reloc_size;
91d6fa6a 11904 unsigned char * rloc;
ba5cdace 11905 unsigned long sym_index;
4b78141a 11906
aca88567 11907 reloc_type = get_reloc_type (rp->r_info);
41e92641 11908
98fb390a 11909 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 11910 continue;
98fb390a
NC		 11911 else if (is_none_reloc (reloc_type))
11912 continue;
11913 else if (is_32bit_abs_reloc (reloc_type)
11914 || is_32bit_pcrel_reloc (reloc_type))
aca88567 11915 reloc_size = 4;
85acf597
RH		 11916 else if (is_64bit_abs_reloc (reloc_type)
11917 || is_64bit_pcrel_reloc (reloc_type))
aca88567 11918 reloc_size = 8;
4dc3c23d
AM		 11919 else if (is_24bit_abs_reloc (reloc_type))
11920 reloc_size = 3;
aca88567
NC		 11921 else if (is_16bit_abs_reloc (reloc_type))
11922 reloc_size = 2;
11923 else
4b78141a 11924 {
bee0ee85
NC		 11925 static unsigned int prev_reloc = 0;
11926 if (reloc_type != prev_reloc)
11927 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11928 reloc_type, printable_section_name (section));
11929 prev_reloc = reloc_type;
4b78141a
NC		 11930 continue;
11931 }
103f02d3 11932
91d6fa6a 11933 rloc = start + rp->r_offset;
c8da6823 11934 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 11935 {
11936 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11937 (unsigned long) rp->r_offset,
74e1a04b 11938 printable_section_name (section));
700dd8b7
L		 11939 continue;
11940 }
103f02d3 11941
ba5cdace
NC		 11942 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11943 if (sym_index >= num_syms)
11944 {
11945 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 11946 sym_index, printable_section_name (section));
ba5cdace
NC		 11947 continue;
11948 }
11949 sym = symtab + sym_index;
41e92641
NC		 11950
11951 /* If the reloc has a symbol associated with it,
55f25fc3
L		 11952 make sure that it is of an appropriate type.
11953
11954 Relocations against symbols without type can happen.
11955 Gcc -feliminate-dwarf2-dups may generate symbols
11956 without type for debug info.
11957
11958 Icc generates relocations against function symbols
11959 instead of local labels.
11960
11961 Relocations against object symbols can happen, eg when
11962 referencing a global array. For an example of this see
11963 the _clz.o binary in libgcc.a. */
aca88567 11964 if (sym != symtab
55f25fc3 11965 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 11966 {
41e92641 11967 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 11968 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 11969 (long int)(rp - relocs),
74e1a04b 11970 printable_section_name (relsec));
aca88567 11971 continue;
5b18a4bc 11972 }
252b5132 11973
4dc3c23d
AM		 11974 addend = 0;
11975 if (is_rela)
11976 addend += rp->r_addend;
c47320c3
AM		 11977 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11978 partial_inplace. */
4dc3c23d
AM		 11979 if (!is_rela
11980 || (elf_header.e_machine == EM_XTENSA
11981 && reloc_type == 1)
11982 || ((elf_header.e_machine == EM_PJ
11983 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 11984 && reloc_type == 1)
11985 || ((elf_header.e_machine == EM_D30V
11986 || elf_header.e_machine == EM_CYGNUS_D30V)
11987 && reloc_type == 12))
91d6fa6a 11988 addend += byte_get (rloc, reloc_size);
cb8f3167 11989
85acf597
RH		 11990 if (is_32bit_pcrel_reloc (reloc_type)
11991 || is_64bit_pcrel_reloc (reloc_type))
11992 {
11993 /* On HPPA, all pc-relative relocations are biased by 8. */
11994 if (elf_header.e_machine == EM_PARISC)
11995 addend -= 8;
91d6fa6a 11996 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 11997 reloc_size);
11998 }
41e92641 11999 else
91d6fa6a 12000 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12001 }
252b5132 12002
5b18a4bc 12003 free (symtab);
d1c4b12b
NC		 12004
12005 if (relocs_return)
12006 {
12007 * (Elf_Internal_Rela **) relocs_return = relocs;
12008 * num_relocs_return = num_relocs;
12009 }
12010 else
12011 free (relocs);
12012
5b18a4bc
NC		 12013 break;
12014 }
5b18a4bc 12015}
103f02d3 12016
cf13d699
NC		 12017#ifdef SUPPORT_DISASSEMBLY
12018static int
12019disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12020{
74e1a04b 12021 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12022
74e1a04b 12023 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12024
12025 return 1;
12026}
12027#endif
12028
12029/* Reads in the contents of SECTION from FILE, returning a pointer
12030 to a malloc'ed buffer or NULL if something went wrong. */
12031
12032static char *
12033get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12034{
12035 bfd_size_type num_bytes;
12036
12037 num_bytes = section->sh_size;
12038
12039 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12040 {
12041 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12042 printable_section_name (section));
cf13d699
NC		 12043 return NULL;
12044 }
12045
3f5e193b
NC		 12046 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12047 _("section contents"));
cf13d699
NC		 12048}
12049
0e602686
NC		 12050/* Uncompresses a section that was compressed using zlib, in place. */
12051
12052static bfd_boolean
12053uncompress_section_contents (unsigned char **buffer,
12054 dwarf_size_type uncompressed_size,
12055 dwarf_size_type *size)
12056{
12057 dwarf_size_type compressed_size = *size;
12058 unsigned char * compressed_buffer = *buffer;
12059 unsigned char * uncompressed_buffer;
12060 z_stream strm;
12061 int rc;
12062
12063 /* It is possible the section consists of several compressed
12064 buffers concatenated together, so we uncompress in a loop. */
12065 /* PR 18313: The state field in the z_stream structure is supposed
12066 to be invisible to the user (ie us), but some compilers will
12067 still complain about it being used without initialisation. So
12068 we first zero the entire z_stream structure and then set the fields
12069 that we need. */
12070 memset (& strm, 0, sizeof strm);
12071 strm.avail_in = compressed_size;
12072 strm.next_in = (Bytef *) compressed_buffer;
12073 strm.avail_out = uncompressed_size;
12074 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12075
12076 rc = inflateInit (& strm);
12077 while (strm.avail_in > 0)
12078 {
12079 if (rc != Z_OK)
12080 goto fail;
12081 strm.next_out = ((Bytef *) uncompressed_buffer
12082 + (uncompressed_size - strm.avail_out));
12083 rc = inflate (&strm, Z_FINISH);
12084 if (rc != Z_STREAM_END)
12085 goto fail;
12086 rc = inflateReset (& strm);
12087 }
12088 rc = inflateEnd (& strm);
12089 if (rc != Z_OK
12090 || strm.avail_out != 0)
12091 goto fail;
12092
12093 *buffer = uncompressed_buffer;
12094 *size = uncompressed_size;
12095 return TRUE;
12096
12097 fail:
12098 free (uncompressed_buffer);
12099 /* Indicate decompression failure. */
12100 *buffer = NULL;
12101 return FALSE;
12102}
dd24e3da 12103
cf13d699
NC		 12104static void
12105dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12106{
0e602686
NC		 12107 Elf_Internal_Shdr * relsec;
12108 bfd_size_type num_bytes;
fd8008d8
L		 12109 unsigned char * data;
12110 unsigned char * end;
12111 unsigned char * real_start;
12112 unsigned char * start;
0e602686 12113 bfd_boolean some_strings_shown;
cf13d699 12114
fd8008d8
L		 12115 real_start = start = (unsigned char *) get_section_contents (section,
12116 file);
cf13d699
NC		 12117 if (start == NULL)
12118 return;
0e602686 12119 num_bytes = section->sh_size;
cf13d699 12120
74e1a04b 12121 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12122
0e602686
NC		 12123 if (decompress_dumps)
12124 {
12125 dwarf_size_type new_size = num_bytes;
12126 dwarf_size_type uncompressed_size = 0;
12127
12128 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12129 {
12130 Elf_Internal_Chdr chdr;
12131 unsigned int compression_header_size
12132 = get_compression_header (& chdr, (unsigned char *) start);
12133
813dabb9 12134 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12135 {
813dabb9
L		 12136 warn (_("section '%s' has unsupported compress type: %d\n"),
12137 printable_section_name (section), chdr.ch_type);
12138 return;
12139 }
12140 else if (chdr.ch_addralign != section->sh_addralign)
12141 {
12142 warn (_("compressed section '%s' is corrupted\n"),
12143 printable_section_name (section));
12144 return;
0e602686 12145 }
813dabb9
L		 12146 uncompressed_size = chdr.ch_size;
12147 start += compression_header_size;
12148 new_size -= compression_header_size;
0e602686
NC		 12149 }
12150 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12151 {
12152 /* Read the zlib header. In this case, it should be "ZLIB"
12153 followed by the uncompressed section size, 8 bytes in
12154 big-endian order. */
12155 uncompressed_size = start[4]; uncompressed_size <<= 8;
12156 uncompressed_size += start[5]; uncompressed_size <<= 8;
12157 uncompressed_size += start[6]; uncompressed_size <<= 8;
12158 uncompressed_size += start[7]; uncompressed_size <<= 8;
12159 uncompressed_size += start[8]; uncompressed_size <<= 8;
12160 uncompressed_size += start[9]; uncompressed_size <<= 8;
12161 uncompressed_size += start[10]; uncompressed_size <<= 8;
12162 uncompressed_size += start[11];
12163 start += 12;
12164 new_size -= 12;
12165 }
12166
12167 if (uncompressed_size
fd8008d8 12168 && uncompress_section_contents (& start,
0e602686
NC		 12169 uncompressed_size, & new_size))
12170 num_bytes = new_size;
12171 }
fd8008d8 12172
cf13d699
NC		 12173 /* If the section being dumped has relocations against it the user might
12174 be expecting these relocations to have been applied. Check for this
12175 case and issue a warning message in order to avoid confusion.
12176 FIXME: Maybe we ought to have an option that dumps a section with
12177 relocs applied ? */
12178 for (relsec = section_headers;
12179 relsec < section_headers + elf_header.e_shnum;
12180 ++relsec)
12181 {
12182 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12183 || relsec->sh_info >= elf_header.e_shnum
12184 || section_headers + relsec->sh_info != section
12185 || relsec->sh_size == 0
12186 || relsec->sh_link >= elf_header.e_shnum)
12187 continue;
12188
12189 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12190 break;
12191 }
12192
cf13d699
NC		 12193 data = start;
12194 end = start + num_bytes;
12195 some_strings_shown = FALSE;
12196
12197 while (data < end)
12198 {
12199 while (!ISPRINT (* data))
12200 if (++ data >= end)
12201 break;
12202
12203 if (data < end)
12204 {
071436c6
NC		 12205 size_t maxlen = end - data;
12206
cf13d699 12207#ifndef __MSVCRT__
c975cc98
NC		 12208 /* PR 11128: Use two separate invocations in order to work
12209 around bugs in the Solaris 8 implementation of printf. */
12210 printf (" [%6tx] ", data - start);
cf13d699 12211#else
071436c6 12212 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12213#endif
4082ef84
NC		 12214 if (maxlen > 0)
12215 {
fd8008d8 12216 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12217 putchar ('\n');
fd8008d8 12218 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12219 }
12220 else
12221 {
12222 printf (_("<corrupt>\n"));
12223 data = end;
12224 }
cf13d699
NC		 12225 some_strings_shown = TRUE;
12226 }
12227 }
12228
12229 if (! some_strings_shown)
12230 printf (_(" No strings found in this section."));
12231
0e602686 12232 free (real_start);
cf13d699
NC		 12233
12234 putchar ('\n');
12235}
12236
12237static void
12238dump_section_as_bytes (Elf_Internal_Shdr * section,
12239 FILE * file,
12240 bfd_boolean relocate)
12241{
12242 Elf_Internal_Shdr * relsec;
0e602686
NC		 12243 bfd_size_type bytes;
12244 bfd_size_type section_size;
12245 bfd_vma addr;
12246 unsigned char * data;
12247 unsigned char * real_start;
12248 unsigned char * start;
12249
12250 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12251 if (start == NULL)
12252 return;
0e602686 12253 section_size = section->sh_size;
cf13d699 12254
74e1a04b 12255 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12256
0e602686
NC		 12257 if (decompress_dumps)
12258 {
12259 dwarf_size_type new_size = section_size;
12260 dwarf_size_type uncompressed_size = 0;
12261
12262 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12263 {
12264 Elf_Internal_Chdr chdr;
12265 unsigned int compression_header_size
12266 = get_compression_header (& chdr, start);
12267
813dabb9 12268 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12269 {
813dabb9
L		 12270 warn (_("section '%s' has unsupported compress type: %d\n"),
12271 printable_section_name (section), chdr.ch_type);
12272 return;
0e602686 12273 }
813dabb9
L		 12274 else if (chdr.ch_addralign != section->sh_addralign)
12275 {
12276 warn (_("compressed section '%s' is corrupted\n"),
12277 printable_section_name (section));
12278 return;
12279 }
12280 uncompressed_size = chdr.ch_size;
12281 start += compression_header_size;
12282 new_size -= compression_header_size;
0e602686
NC		 12283 }
12284 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12285 {
12286 /* Read the zlib header. In this case, it should be "ZLIB"
12287 followed by the uncompressed section size, 8 bytes in
12288 big-endian order. */
12289 uncompressed_size = start[4]; uncompressed_size <<= 8;
12290 uncompressed_size += start[5]; uncompressed_size <<= 8;
12291 uncompressed_size += start[6]; uncompressed_size <<= 8;
12292 uncompressed_size += start[7]; uncompressed_size <<= 8;
12293 uncompressed_size += start[8]; uncompressed_size <<= 8;
12294 uncompressed_size += start[9]; uncompressed_size <<= 8;
12295 uncompressed_size += start[10]; uncompressed_size <<= 8;
12296 uncompressed_size += start[11];
12297 start += 12;
12298 new_size -= 12;
12299 }
12300
12301 if (uncompressed_size
12302 && uncompress_section_contents (& start, uncompressed_size,
12303 & new_size))
12304 section_size = new_size;
12305 }
14ae95f2 12306
cf13d699
NC		 12307 if (relocate)
12308 {
0e602686 12309 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12310 }
12311 else
12312 {
12313 /* If the section being dumped has relocations against it the user might
12314 be expecting these relocations to have been applied. Check for this
12315 case and issue a warning message in order to avoid confusion.
12316 FIXME: Maybe we ought to have an option that dumps a section with
12317 relocs applied ? */
12318 for (relsec = section_headers;
12319 relsec < section_headers + elf_header.e_shnum;
12320 ++relsec)
12321 {
12322 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12323 || relsec->sh_info >= elf_header.e_shnum
12324 || section_headers + relsec->sh_info != section
12325 || relsec->sh_size == 0
12326 || relsec->sh_link >= elf_header.e_shnum)
12327 continue;
12328
12329 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12330 break;
12331 }
12332 }
12333
12334 addr = section->sh_addr;
0e602686 12335 bytes = section_size;
cf13d699
NC		 12336 data = start;
12337
12338 while (bytes)
12339 {
12340 int j;
12341 int k;
12342 int lbytes;
12343
12344 lbytes = (bytes > 16 ? 16 : bytes);
12345
12346 printf (" 0x%8.8lx ", (unsigned long) addr);
12347
12348 for (j = 0; j < 16; j++)
12349 {
12350 if (j < lbytes)
12351 printf ("%2.2x", data[j]);
12352 else
12353 printf (" ");
12354
12355 if ((j & 3) == 3)
12356 printf (" ");
12357 }
12358
12359 for (j = 0; j < lbytes; j++)
12360 {
12361 k = data[j];
12362 if (k >= ' ' && k < 0x7f)
12363 printf ("%c", k);
12364 else
12365 printf (".");
12366 }
12367
12368 putchar ('\n');
12369
12370 data += lbytes;
12371 addr += lbytes;
12372 bytes -= lbytes;
12373 }
12374
0e602686 12375 free (real_start);
cf13d699
NC		 12376
12377 putchar ('\n');
12378}
12379
d966045b
DJ		 12380static int
12381load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12382 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12383{
2cf0635d 12384 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12385 char buf [64];
1007acb3 12386
19e6b90e
L		 12387 /* If it is already loaded, do nothing. */
12388 if (section->start != NULL)
12389 return 1;
1007acb3 12390
19e6b90e
L		 12391 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12392 section->address = sec->sh_addr;
06614111 12393 section->user_data = NULL;
3f5e193b
NC		 12394 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12395 sec->sh_offset, 1,
12396 sec->sh_size, buf);
59245841
NC		 12397 if (section->start == NULL)
12398 section->size = 0;
12399 else
12400 {
77115a4a
L		 12401 unsigned char *start = section->start;
12402 dwarf_size_type size = sec->sh_size;
dab394de 12403 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12404
12405 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12406 {
12407 Elf_Internal_Chdr chdr;
12408 unsigned int compression_header_size
12409 = get_compression_header (&chdr, start);
813dabb9
L		 12410 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12411 {
12412 warn (_("section '%s' has unsupported compress type: %d\n"),
12413 section->name, chdr.ch_type);
12414 return 0;
12415 }
12416 else if (chdr.ch_addralign != sec->sh_addralign)
12417 {
12418 warn (_("compressed section '%s' is corrupted\n"),
12419 section->name);
12420 return 0;
12421 }
dab394de 12422 uncompressed_size = chdr.ch_size;
77115a4a
L		 12423 start += compression_header_size;
12424 size -= compression_header_size;
12425 }
dab394de
L		 12426 else if (size > 12 && streq ((char *) start, "ZLIB"))
12427 {
12428 /* Read the zlib header. In this case, it should be "ZLIB"
12429 followed by the uncompressed section size, 8 bytes in
12430 big-endian order. */
12431 uncompressed_size = start[4]; uncompressed_size <<= 8;
12432 uncompressed_size += start[5]; uncompressed_size <<= 8;
12433 uncompressed_size += start[6]; uncompressed_size <<= 8;
12434 uncompressed_size += start[7]; uncompressed_size <<= 8;
12435 uncompressed_size += start[8]; uncompressed_size <<= 8;
12436 uncompressed_size += start[9]; uncompressed_size <<= 8;
12437 uncompressed_size += start[10]; uncompressed_size <<= 8;
12438 uncompressed_size += start[11];
12439 start += 12;
12440 size -= 12;
12441 }
12442
12443 if (uncompressed_size
12444 && uncompress_section_contents (&start, uncompressed_size,
12445 &size))
77115a4a
L		 12446 {
12447 /* Free the compressed buffer, update the section buffer
12448 and the section size if uncompress is successful. */
12449 free (section->start);
12450 section->start = start;
77115a4a
L		 12451 }
12452 section->size = size;
59245841 12453 }
4a114e3e 12454
1b315056
CS		 12455 if (section->start == NULL)
12456 return 0;
12457
19e6b90e 12458 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12459 apply_relocations ((FILE *) file, sec, section->start, section->size,
12460 & section->reloc_info, & section->num_relocs);
12461 else
12462 {
12463 section->reloc_info = NULL;
12464 section->num_relocs = 0;
12465 }
1007acb3 12466
1b315056 12467 return 1;
1007acb3
L		 12468}
12469
657d0d47
CC		 12470/* If this is not NULL, load_debug_section will only look for sections
12471 within the list of sections given here. */
12472unsigned int *section_subset = NULL;
12473
d966045b 12474int
2cf0635d 12475load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12476{
2cf0635d
NC		 12477 struct dwarf_section * section = &debug_displays [debug].section;
12478 Elf_Internal_Shdr * sec;
d966045b
DJ		 12479
12480 /* Locate the debug section. */
657d0d47 12481 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12482 if (sec != NULL)
12483 section->name = section->uncompressed_name;
12484 else
12485 {
657d0d47 12486 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12487 if (sec != NULL)
12488 section->name = section->compressed_name;
12489 }
12490 if (sec == NULL)
12491 return 0;
12492
657d0d47
CC		 12493 /* If we're loading from a subset of sections, and we've loaded
12494 a section matching this name before, it's likely that it's a
12495 different one. */
12496 if (section_subset != NULL)
12497 free_debug_section (debug);
12498
3f5e193b 12499 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12500}
12501
19e6b90e
L		 12502void
12503free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12504{
2cf0635d 12505 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12506
19e6b90e
L		 12507 if (section->start == NULL)
12508 return;
1007acb3 12509
19e6b90e
L		 12510 free ((char *) section->start);
12511 section->start = NULL;
12512 section->address = 0;
12513 section->size = 0;
1007acb3
L		 12514}
12515
1007acb3 12516static int
657d0d47 12517display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12518{
2cf0635d 12519 char * name = SECTION_NAME (section);
74e1a04b 12520 const char * print_name = printable_section_name (section);
19e6b90e
L		 12521 bfd_size_type length;
12522 int result = 1;
3f5e193b 12523 int i;
1007acb3 12524
19e6b90e
L		 12525 length = section->sh_size;
12526 if (length == 0)
1007acb3 12527 {
74e1a04b 12528 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12529 return 0;
1007acb3 12530 }
5dff79d8
NC		 12531 if (section->sh_type == SHT_NOBITS)
12532 {
12533 /* There is no point in dumping the contents of a debugging section
12534 which has the NOBITS type - the bits in the file will be random.
12535 This can happen when a file containing a .eh_frame section is
12536 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12537 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12538 print_name);
5dff79d8
NC		 12539 return 0;
12540 }
1007acb3 12541
0112cd26 12542 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12543 name = ".debug_info";
1007acb3 12544
19e6b90e
L		 12545 /* See if we know how to display the contents of this section. */
12546 for (i = 0; i < max; i++)
1b315056 12547 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12548 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12549 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12550 {
2cf0635d 12551 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12552 int secondary = (section != find_section (name));
12553
12554 if (secondary)
3f5e193b 12555 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12556
b40bf0a2
NC		 12557 if (i == line && const_strneq (name, ".debug_line."))
12558 sec->name = name;
12559 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12560 sec->name = sec->uncompressed_name;
12561 else
12562 sec->name = sec->compressed_name;
3f5e193b
NC		 12563 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12564 section, file))
19e6b90e 12565 {
657d0d47
CC		 12566 /* If this debug section is part of a CU/TU set in a .dwp file,
12567 restrict load_debug_section to the sections in that set. */
12568 section_subset = find_cu_tu_set (file, shndx);
12569
19e6b90e 12570 result &= debug_displays[i].display (sec, file);
1007acb3 12571
657d0d47
CC		 12572 section_subset = NULL;
12573
d966045b 12574 if (secondary || (i != info && i != abbrev))
3f5e193b 12575 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12576 }
1007acb3 12577
19e6b90e
L		 12578 break;
12579 }
1007acb3 12580
19e6b90e 12581 if (i == max)
1007acb3 12582 {
74e1a04b 12583 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12584 result = 0;
1007acb3
L		 12585 }
12586
19e6b90e 12587 return result;
5b18a4bc 12588}
103f02d3 12589
aef1f6d0
DJ		 12590/* Set DUMP_SECTS for all sections where dumps were requested
12591 based on section name. */
12592
12593static void
12594initialise_dumps_byname (void)
12595{
2cf0635d 12596 struct dump_list_entry * cur;
aef1f6d0
DJ		 12597
12598 for (cur = dump_sects_byname; cur; cur = cur->next)
12599 {
12600 unsigned int i;
12601 int any;
12602
12603 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12604 if (streq (SECTION_NAME (section_headers + i), cur->name))
12605 {
09c11c86 12606 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12607 any = 1;
12608 }
12609
12610 if (!any)
12611 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12612 cur->name);
12613 }
12614}
12615
5b18a4bc 12616static void
2cf0635d 12617process_section_contents (FILE * file)
5b18a4bc 12618{
2cf0635d 12619 Elf_Internal_Shdr * section;
19e6b90e 12620 unsigned int i;
103f02d3 12621
19e6b90e
L		 12622 if (! do_dump)
12623 return;
103f02d3 12624
aef1f6d0
DJ		 12625 initialise_dumps_byname ();
12626
19e6b90e
L		 12627 for (i = 0, section = section_headers;
12628 i < elf_header.e_shnum && i < num_dump_sects;
12629 i++, section++)
12630 {
12631#ifdef SUPPORT_DISASSEMBLY
12632 if (dump_sects[i] & DISASS_DUMP)
12633 disassemble_section (section, file);
12634#endif
12635 if (dump_sects[i] & HEX_DUMP)
cf13d699 12636 dump_section_as_bytes (section, file, FALSE);
103f02d3 12637
cf13d699
NC		 12638 if (dump_sects[i] & RELOC_DUMP)
12639 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12640
12641 if (dump_sects[i] & STRING_DUMP)
12642 dump_section_as_strings (section, file);
cf13d699
NC		 12643
12644 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12645 display_debug_section (i, section, file);
5b18a4bc 12646 }
103f02d3 12647
19e6b90e
L		 12648 /* Check to see if the user requested a
12649 dump of a section that does not exist. */
12650 while (i++ < num_dump_sects)
12651 if (dump_sects[i])
12652 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12653}
103f02d3 12654
5b18a4bc 12655static void
19e6b90e 12656process_mips_fpe_exception (int mask)
5b18a4bc 12657{
19e6b90e
L		 12658 if (mask)
12659 {
12660 int first = 1;
12661 if (mask & OEX_FPU_INEX)
12662 fputs ("INEX", stdout), first = 0;
12663 if (mask & OEX_FPU_UFLO)
12664 printf ("%sUFLO", first ? "" : "|"), first = 0;
12665 if (mask & OEX_FPU_OFLO)
12666 printf ("%sOFLO", first ? "" : "|"), first = 0;
12667 if (mask & OEX_FPU_DIV0)
12668 printf ("%sDIV0", first ? "" : "|"), first = 0;
12669 if (mask & OEX_FPU_INVAL)
12670 printf ("%sINVAL", first ? "" : "|");
12671 }
5b18a4bc 12672 else
19e6b90e 12673 fputs ("0", stdout);
5b18a4bc 12674}
103f02d3 12675
f6f0e17b
NC		 12676/* Display's the value of TAG at location P. If TAG is
12677 greater than 0 it is assumed to be an unknown tag, and
12678 a message is printed to this effect. Otherwise it is
12679 assumed that a message has already been printed.
12680
12681 If the bottom bit of TAG is set it assumed to have a
12682 string value, otherwise it is assumed to have an integer
12683 value.
12684
12685 Returns an updated P pointing to the first unread byte
12686 beyond the end of TAG's value.
12687
12688 Reads at or beyond END will not be made. */
12689
12690static unsigned char *
12691display_tag_value (int tag,
12692 unsigned char * p,
12693 const unsigned char * const end)
12694{
12695 unsigned long val;
12696
12697 if (tag > 0)
12698 printf (" Tag_unknown_%d: ", tag);
12699
12700 if (p >= end)
12701 {
4082ef84 12702 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12703 }
12704 else if (tag & 1)
12705 {
071436c6
NC		 12706 /* PR 17531 file: 027-19978-0.004. */
12707 size_t maxlen = (end - p) - 1;
12708
12709 putchar ('"');
4082ef84
NC		 12710 if (maxlen > 0)
12711 {
12712 print_symbol ((int) maxlen, (const char *) p);
12713 p += strnlen ((char *) p, maxlen) + 1;
12714 }
12715 else
12716 {
12717 printf (_("<corrupt string tag>"));
12718 p = (unsigned char *) end;
12719 }
071436c6 12720 printf ("\"\n");
f6f0e17b
NC		 12721 }
12722 else
12723 {
12724 unsigned int len;
12725
12726 val = read_uleb128 (p, &len, end);
12727 p += len;
12728 printf ("%ld (0x%lx)\n", val, val);
12729 }
12730
4082ef84 12731 assert (p <= end);
f6f0e17b
NC		 12732 return p;
12733}
12734
11c1ff18
PB		 12735/* ARM EABI attributes section. */
12736typedef struct
12737{
70e99720 12738 unsigned int tag;
2cf0635d 12739 const char * name;
11c1ff18 12740 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12741 unsigned int type;
2cf0635d 12742 const char ** table;
11c1ff18
PB		 12743} arm_attr_public_tag;
12744
2cf0635d 12745static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12746 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
bca38921 12747 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
2cf0635d
NC		 12748static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12749static const char * arm_attr_tag_THUMB_ISA_use[] =
11c1ff18 12750 {"No", "Thumb-1", "Thumb-2"};
75375b3e 12751static const char * arm_attr_tag_FP_arch[] =
bca38921 12752 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12753 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12754static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12755static const char * arm_attr_tag_Advanced_SIMD_arch[] =
bca38921 12756 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
2cf0635d 12757static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12758 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12759 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12760static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12761 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12762static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12763 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12764static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12765 {"Absolute", "PC-relative", "None"};
2cf0635d 12766static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12767 {"None", "direct", "GOT-indirect"};
2cf0635d 12768static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12769 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12770static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12771static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12772 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12773static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12774static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12775static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12776 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12777static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12778 {"Unused", "small", "int", "forced to int"};
2cf0635d 12779static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12780 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12781static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12782 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12783static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12784 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12785static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12786 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12787 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12788static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12789 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12790 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12791static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12792static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12793 {"Not Allowed", "Allowed"};
2cf0635d 12794static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12795 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12796static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12797 {"Not Allowed", "Allowed"};
12798static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12799 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12800 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12801static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12802static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12803 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12804 "TrustZone and Virtualization Extensions"};
dd24e3da 12805static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12806 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12807
12808#define LOOKUP(id, name) \
12809 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12810static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12811{
12812 {4, "CPU_raw_name", 1, NULL},
12813 {5, "CPU_name", 1, NULL},
12814 LOOKUP(6, CPU_arch),
12815 {7, "CPU_arch_profile", 0, NULL},
12816 LOOKUP(8, ARM_ISA_use),
12817 LOOKUP(9, THUMB_ISA_use),
75375b3e 12818 LOOKUP(10, FP_arch),
11c1ff18 12819 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12820 LOOKUP(12, Advanced_SIMD_arch),
12821 LOOKUP(13, PCS_config),
11c1ff18
PB		 12822 LOOKUP(14, ABI_PCS_R9_use),
12823 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12824 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12825 LOOKUP(17, ABI_PCS_GOT_use),
12826 LOOKUP(18, ABI_PCS_wchar_t),
12827 LOOKUP(19, ABI_FP_rounding),
12828 LOOKUP(20, ABI_FP_denormal),
12829 LOOKUP(21, ABI_FP_exceptions),
12830 LOOKUP(22, ABI_FP_user_exceptions),
12831 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12832 {24, "ABI_align_needed", 0, NULL},
12833 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12834 LOOKUP(26, ABI_enum_size),
12835 LOOKUP(27, ABI_HardFP_use),
12836 LOOKUP(28, ABI_VFP_args),
12837 LOOKUP(29, ABI_WMMX_args),
12838 LOOKUP(30, ABI_optimization_goals),
12839 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12840 {32, "compatibility", 0, NULL},
f5f53991 12841 LOOKUP(34, CPU_unaligned_access),
75375b3e 12842 LOOKUP(36, FP_HP_extension),
8e79c3df 12843 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12844 LOOKUP(42, MPextension_use),
12845 LOOKUP(44, DIV_use),
f5f53991
AS		 12846 {64, "nodefaults", 0, NULL},
12847 {65, "also_compatible_with", 0, NULL},
12848 LOOKUP(66, T2EE_use),
12849 {67, "conformance", 1, NULL},
12850 LOOKUP(68, Virtualization_use),
cd21e546 12851 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12852};
12853#undef LOOKUP
12854
11c1ff18 12855static unsigned char *
f6f0e17b
NC		 12856display_arm_attribute (unsigned char * p,
12857 const unsigned char * const end)
11c1ff18 12858{
70e99720 12859 unsigned int tag;
11c1ff18 12860 unsigned int len;
70e99720 12861 unsigned int val;
2cf0635d 12862 arm_attr_public_tag * attr;
11c1ff18 12863 unsigned i;
70e99720 12864 unsigned int type;
11c1ff18 12865
f6f0e17b 12866 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12867 p += len;
12868 attr = NULL;
2cf0635d 12869 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 12870 {
12871 if (arm_attr_public_tags[i].tag == tag)
12872 {
12873 attr = &arm_attr_public_tags[i];
12874 break;
12875 }
12876 }
12877
12878 if (attr)
12879 {
12880 printf (" Tag_%s: ", attr->name);
12881 switch (attr->type)
12882 {
12883 case 0:
12884 switch (tag)
12885 {
12886 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 12887 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12888 p += len;
12889 switch (val)
12890 {
2b692964
NC		 12891 case 0: printf (_("None\n")); break;
12892 case 'A': printf (_("Application\n")); break;
12893 case 'R': printf (_("Realtime\n")); break;
12894 case 'M': printf (_("Microcontroller\n")); break;
12895 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 12896 default: printf ("??? (%d)\n", val); break;
12897 }
12898 break;
12899
75375b3e 12900 case 24: /* Tag_align_needed. */
f6f0e17b 12901 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12902 p += len;
12903 switch (val)
12904 {
2b692964
NC		 12905 case 0: printf (_("None\n")); break;
12906 case 1: printf (_("8-byte\n")); break;
12907 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 12908 case 3: printf ("??? 3\n"); break;
12909 default:
12910 if (val <= 12)
dd24e3da 12911 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12912 1 << val);
12913 else
12914 printf ("??? (%d)\n", val);
12915 break;
12916 }
12917 break;
12918
12919 case 25: /* Tag_align_preserved. */
f6f0e17b 12920 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 12921 p += len;
12922 switch (val)
12923 {
2b692964
NC		 12924 case 0: printf (_("None\n")); break;
12925 case 1: printf (_("8-byte, except leaf SP\n")); break;
12926 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 12927 case 3: printf ("??? 3\n"); break;
12928 default:
12929 if (val <= 12)
dd24e3da 12930 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 12931 1 << val);
12932 else
12933 printf ("??? (%d)\n", val);
12934 break;
12935 }
12936 break;
12937
11c1ff18 12938 case 32: /* Tag_compatibility. */
071436c6 12939 {
071436c6
NC		 12940 val = read_uleb128 (p, &len, end);
12941 p += len;
071436c6 12942 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 12943 if (p < end - 1)
12944 {
12945 size_t maxlen = (end - p) - 1;
12946
12947 print_symbol ((int) maxlen, (const char *) p);
12948 p += strnlen ((char *) p, maxlen) + 1;
12949 }
12950 else
12951 {
12952 printf (_("<corrupt>"));
12953 p = (unsigned char *) end;
12954 }
071436c6 12955 putchar ('\n');
071436c6 12956 }
11c1ff18
PB		 12957 break;
12958
f5f53991 12959 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 12960 /* PR 17531: file: 001-505008-0.01. */
12961 if (p < end)
12962 p++;
2b692964 12963 printf (_("True\n"));
f5f53991
AS		 12964 break;
12965
12966 case 65: /* Tag_also_compatible_with. */
f6f0e17b 12967 val = read_uleb128 (p, &len, end);
f5f53991
AS		 12968 p += len;
12969 if (val == 6 /* Tag_CPU_arch. */)
12970 {
f6f0e17b 12971 val = read_uleb128 (p, &len, end);
f5f53991 12972 p += len;
071436c6 12973 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 12974 printf ("??? (%d)\n", val);
12975 else
12976 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12977 }
12978 else
12979 printf ("???\n");
071436c6
NC		 12980 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12981 ;
f5f53991
AS		 12982 break;
12983
11c1ff18 12984 default:
bee0ee85
NC		 12985 printf (_("<unknown: %d>\n"), tag);
12986 break;
11c1ff18
PB		 12987 }
12988 return p;
12989
12990 case 1:
f6f0e17b 12991 return display_tag_value (-1, p, end);
11c1ff18 12992 case 2:
f6f0e17b 12993 return display_tag_value (0, p, end);
11c1ff18
PB		 12994
12995 default:
12996 assert (attr->type & 0x80);
f6f0e17b 12997 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 12998 p += len;
12999 type = attr->type & 0x7f;
13000 if (val >= type)
13001 printf ("??? (%d)\n", val);
13002 else
13003 printf ("%s\n", attr->table[val]);
13004 return p;
13005 }
13006 }
11c1ff18 13007
f6f0e17b 13008 return display_tag_value (tag, p, end);
11c1ff18
PB		 13009}
13010
104d59d1 13011static unsigned char *
60bca95a 13012display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13013 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13014 const unsigned char * const end)
104d59d1
JM		 13015{
13016 int tag;
13017 unsigned int len;
13018 int val;
104d59d1 13019
f6f0e17b 13020 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13021 p += len;
13022
13023 /* Tag_compatibility is the only generic GNU attribute defined at
13024 present. */
13025 if (tag == 32)
13026 {
f6f0e17b 13027 val = read_uleb128 (p, &len, end);
104d59d1 13028 p += len;
071436c6
NC		 13029
13030 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13031 if (p == end)
13032 {
071436c6 13033 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13034 warn (_("corrupt vendor attribute\n"));
13035 }
13036 else
13037 {
4082ef84
NC		 13038 if (p < end - 1)
13039 {
13040 size_t maxlen = (end - p) - 1;
071436c6 13041
4082ef84
NC		 13042 print_symbol ((int) maxlen, (const char *) p);
13043 p += strnlen ((char *) p, maxlen) + 1;
13044 }
13045 else
13046 {
13047 printf (_("<corrupt>"));
13048 p = (unsigned char *) end;
13049 }
071436c6 13050 putchar ('\n');
f6f0e17b 13051 }
104d59d1
JM		 13052 return p;
13053 }
13054
13055 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13056 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13057
f6f0e17b 13058 return display_tag_value (tag, p, end);
104d59d1
JM		 13059}
13060
34c8bcba 13061static unsigned char *
f6f0e17b
NC		 13062display_power_gnu_attribute (unsigned char * p,
13063 int tag,
13064 const unsigned char * const end)
34c8bcba 13065{
34c8bcba
JM		 13066 unsigned int len;
13067 int val;
13068
13069 if (tag == Tag_GNU_Power_ABI_FP)
13070 {
f6f0e17b 13071 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13072 p += len;
13073 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13074
34c8bcba
JM		 13075 switch (val)
13076 {
13077 case 0:
2b692964 13078 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13079 break;
13080 case 1:
2b692964 13081 printf (_("Hard float\n"));
34c8bcba
JM		 13082 break;
13083 case 2:
2b692964 13084 printf (_("Soft float\n"));
34c8bcba 13085 break;
3c7b9897 13086 case 3:
2b692964 13087 printf (_("Single-precision hard float\n"));
3c7b9897 13088 break;
34c8bcba
JM		 13089 default:
13090 printf ("??? (%d)\n", val);
13091 break;
13092 }
13093 return p;
13094 }
13095
c6e65352
DJ		 13096 if (tag == Tag_GNU_Power_ABI_Vector)
13097 {
f6f0e17b 13098 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13099 p += len;
13100 printf (" Tag_GNU_Power_ABI_Vector: ");
13101 switch (val)
13102 {
13103 case 0:
2b692964 13104 printf (_("Any\n"));
c6e65352
DJ		 13105 break;
13106 case 1:
2b692964 13107 printf (_("Generic\n"));
c6e65352
DJ		 13108 break;
13109 case 2:
13110 printf ("AltiVec\n");
13111 break;
13112 case 3:
13113 printf ("SPE\n");
13114 break;
13115 default:
13116 printf ("??? (%d)\n", val);
13117 break;
13118 }
13119 return p;
13120 }
13121
f82e0623
NF		 13122 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13123 {
f6f0e17b
NC		 13124 if (p == end)
13125 {
071436c6 13126 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13127 return p;
13128 }
0b4362b0 13129
f6f0e17b 13130 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13131 p += len;
13132 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13133 switch (val)
13134 {
13135 case 0:
2b692964 13136 printf (_("Any\n"));
f82e0623
NF		 13137 break;
13138 case 1:
13139 printf ("r3/r4\n");
13140 break;
13141 case 2:
2b692964 13142 printf (_("Memory\n"));
f82e0623
NF		 13143 break;
13144 default:
13145 printf ("??? (%d)\n", val);
13146 break;
13147 }
13148 return p;
13149 }
13150
f6f0e17b 13151 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13152}
13153
643f7afb
AK		 13154static unsigned char *
13155display_s390_gnu_attribute (unsigned char * p,
13156 int tag,
13157 const unsigned char * const end)
13158{
13159 unsigned int len;
13160 int val;
13161
13162 if (tag == Tag_GNU_S390_ABI_Vector)
13163 {
13164 val = read_uleb128 (p, &len, end);
13165 p += len;
13166 printf (" Tag_GNU_S390_ABI_Vector: ");
13167
13168 switch (val)
13169 {
13170 case 0:
13171 printf (_("any\n"));
13172 break;
13173 case 1:
13174 printf (_("software\n"));
13175 break;
13176 case 2:
13177 printf (_("hardware\n"));
13178 break;
13179 default:
13180 printf ("??? (%d)\n", val);
13181 break;
13182 }
13183 return p;
13184 }
13185
13186 return display_tag_value (tag & 1, p, end);
13187}
13188
9e8c70f9
DM		 13189static void
13190display_sparc_hwcaps (int mask)
13191{
13192 if (mask)
13193 {
13194 int first = 1;
071436c6 13195
9e8c70f9
DM		 13196 if (mask & ELF_SPARC_HWCAP_MUL32)
13197 fputs ("mul32", stdout), first = 0;
13198 if (mask & ELF_SPARC_HWCAP_DIV32)
13199 printf ("%sdiv32", first ? "" : "|"), first = 0;
13200 if (mask & ELF_SPARC_HWCAP_FSMULD)
13201 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13202 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13203 printf ("%sv8plus", first ? "" : "|"), first = 0;
13204 if (mask & ELF_SPARC_HWCAP_POPC)
13205 printf ("%spopc", first ? "" : "|"), first = 0;
13206 if (mask & ELF_SPARC_HWCAP_VIS)
13207 printf ("%svis", first ? "" : "|"), first = 0;
13208 if (mask & ELF_SPARC_HWCAP_VIS2)
13209 printf ("%svis2", first ? "" : "|"), first = 0;
13210 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13211 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13212 if (mask & ELF_SPARC_HWCAP_FMAF)
13213 printf ("%sfmaf", first ? "" : "|"), first = 0;
13214 if (mask & ELF_SPARC_HWCAP_VIS3)
13215 printf ("%svis3", first ? "" : "|"), first = 0;
13216 if (mask & ELF_SPARC_HWCAP_HPC)
13217 printf ("%shpc", first ? "" : "|"), first = 0;
13218 if (mask & ELF_SPARC_HWCAP_RANDOM)
13219 printf ("%srandom", first ? "" : "|"), first = 0;
13220 if (mask & ELF_SPARC_HWCAP_TRANS)
13221 printf ("%strans", first ? "" : "|"), first = 0;
13222 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13223 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13224 if (mask & ELF_SPARC_HWCAP_IMA)
13225 printf ("%sima", first ? "" : "|"), first = 0;
13226 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13227 printf ("%scspare", first ? "" : "|"), first = 0;
13228 }
13229 else
071436c6
NC		 13230 fputc ('0', stdout);
13231 fputc ('\n', stdout);
9e8c70f9
DM		 13232}
13233
3d68f91c
JM		 13234static void
13235display_sparc_hwcaps2 (int mask)
13236{
13237 if (mask)
13238 {
13239 int first = 1;
071436c6 13240
3d68f91c
JM		 13241 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13242 fputs ("fjathplus", stdout), first = 0;
13243 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13244 printf ("%svis3b", first ? "" : "|"), first = 0;
13245 if (mask & ELF_SPARC_HWCAP2_ADP)
13246 printf ("%sadp", first ? "" : "|"), first = 0;
13247 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13248 printf ("%ssparc5", first ? "" : "|"), first = 0;
13249 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13250 printf ("%smwait", first ? "" : "|"), first = 0;
13251 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13252 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13253 if (mask & ELF_SPARC_HWCAP2_XMONT)
13254 printf ("%sxmont2", first ? "" : "|"), first = 0;
13255 if (mask & ELF_SPARC_HWCAP2_NSEC)
13256 printf ("%snsec", first ? "" : "|"), first = 0;
13257 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13258 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13259 if (mask & ELF_SPARC_HWCAP2_FJDES)
13260 printf ("%sfjdes", first ? "" : "|"), first = 0;
13261 if (mask & ELF_SPARC_HWCAP2_FJAES)
13262 printf ("%sfjaes", first ? "" : "|"), first = 0;
13263 }
13264 else
071436c6
NC		 13265 fputc ('0', stdout);
13266 fputc ('\n', stdout);
3d68f91c
JM		 13267}
13268
9e8c70f9 13269static unsigned char *
f6f0e17b
NC		 13270display_sparc_gnu_attribute (unsigned char * p,
13271 int tag,
13272 const unsigned char * const end)
9e8c70f9 13273{
3d68f91c
JM		 13274 unsigned int len;
13275 int val;
13276
9e8c70f9
DM		 13277 if (tag == Tag_GNU_Sparc_HWCAPS)
13278 {
f6f0e17b 13279 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13280 p += len;
13281 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13282 display_sparc_hwcaps (val);
13283 return p;
3d68f91c
JM		 13284 }
13285 if (tag == Tag_GNU_Sparc_HWCAPS2)
13286 {
13287 val = read_uleb128 (p, &len, end);
13288 p += len;
13289 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13290 display_sparc_hwcaps2 (val);
13291 return p;
13292 }
9e8c70f9 13293
f6f0e17b 13294 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13295}
13296
351cdf24
MF		 13297static void
13298print_mips_fp_abi_value (int val)
13299{
13300 switch (val)
13301 {
13302 case Val_GNU_MIPS_ABI_FP_ANY:
13303 printf (_("Hard or soft float\n"));
13304 break;
13305 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13306 printf (_("Hard float (double precision)\n"));
13307 break;
13308 case Val_GNU_MIPS_ABI_FP_SINGLE:
13309 printf (_("Hard float (single precision)\n"));
13310 break;
13311 case Val_GNU_MIPS_ABI_FP_SOFT:
13312 printf (_("Soft float\n"));
13313 break;
13314 case Val_GNU_MIPS_ABI_FP_OLD_64:
13315 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13316 break;
13317 case Val_GNU_MIPS_ABI_FP_XX:
13318 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13319 break;
13320 case Val_GNU_MIPS_ABI_FP_64:
13321 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13322 break;
13323 case Val_GNU_MIPS_ABI_FP_64A:
13324 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13325 break;
3350cc01
CM		 13326 case Val_GNU_MIPS_ABI_FP_NAN2008:
13327 printf (_("NaN 2008 compatibility\n"));
13328 break;
351cdf24
MF		 13329 default:
13330 printf ("??? (%d)\n", val);
13331 break;
13332 }
13333}
13334
2cf19d5c 13335static unsigned char *
f6f0e17b
NC		 13336display_mips_gnu_attribute (unsigned char * p,
13337 int tag,
13338 const unsigned char * const end)
2cf19d5c 13339{
2cf19d5c
JM		 13340 if (tag == Tag_GNU_MIPS_ABI_FP)
13341 {
f6f0e17b
NC		 13342 unsigned int len;
13343 int val;
13344
13345 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13346 p += len;
13347 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13348
351cdf24
MF		 13349 print_mips_fp_abi_value (val);
13350
2cf19d5c
JM		 13351 return p;
13352 }
13353
a9f58168
CF		 13354 if (tag == Tag_GNU_MIPS_ABI_MSA)
13355 {
13356 unsigned int len;
13357 int val;
13358
13359 val = read_uleb128 (p, &len, end);
13360 p += len;
13361 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13362
13363 switch (val)
13364 {
13365 case Val_GNU_MIPS_ABI_MSA_ANY:
13366 printf (_("Any MSA or not\n"));
13367 break;
13368 case Val_GNU_MIPS_ABI_MSA_128:
13369 printf (_("128-bit MSA\n"));
13370 break;
13371 default:
13372 printf ("??? (%d)\n", val);
13373 break;
13374 }
13375 return p;
13376 }
13377
f6f0e17b 13378 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13379}
13380
59e6276b 13381static unsigned char *
f6f0e17b
NC		 13382display_tic6x_attribute (unsigned char * p,
13383 const unsigned char * const end)
59e6276b
JM		 13384{
13385 int tag;
13386 unsigned int len;
13387 int val;
13388
f6f0e17b 13389 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13390 p += len;
13391
13392 switch (tag)
13393 {
75fa6dc1 13394 case Tag_ISA:
f6f0e17b 13395 val = read_uleb128 (p, &len, end);
59e6276b 13396 p += len;
75fa6dc1 13397 printf (" Tag_ISA: ");
59e6276b
JM		 13398
13399 switch (val)
13400 {
75fa6dc1 13401 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13402 printf (_("None\n"));
13403 break;
75fa6dc1 13404 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13405 printf ("C62x\n");
13406 break;
75fa6dc1 13407 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13408 printf ("C67x\n");
13409 break;
75fa6dc1 13410 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13411 printf ("C67x+\n");
13412 break;
75fa6dc1 13413 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13414 printf ("C64x\n");
13415 break;
75fa6dc1 13416 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13417 printf ("C64x+\n");
13418 break;
75fa6dc1 13419 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13420 printf ("C674x\n");
13421 break;
13422 default:
13423 printf ("??? (%d)\n", val);
13424 break;
13425 }
13426 return p;
13427
87779176 13428 case Tag_ABI_wchar_t:
f6f0e17b 13429 val = read_uleb128 (p, &len, end);
87779176
JM		 13430 p += len;
13431 printf (" Tag_ABI_wchar_t: ");
13432 switch (val)
13433 {
13434 case 0:
13435 printf (_("Not used\n"));
13436 break;
13437 case 1:
13438 printf (_("2 bytes\n"));
13439 break;
13440 case 2:
13441 printf (_("4 bytes\n"));
13442 break;
13443 default:
13444 printf ("??? (%d)\n", val);
13445 break;
13446 }
13447 return p;
13448
13449 case Tag_ABI_stack_align_needed:
f6f0e17b 13450 val = read_uleb128 (p, &len, end);
87779176
JM		 13451 p += len;
13452 printf (" Tag_ABI_stack_align_needed: ");
13453 switch (val)
13454 {
13455 case 0:
13456 printf (_("8-byte\n"));
13457 break;
13458 case 1:
13459 printf (_("16-byte\n"));
13460 break;
13461 default:
13462 printf ("??? (%d)\n", val);
13463 break;
13464 }
13465 return p;
13466
13467 case Tag_ABI_stack_align_preserved:
f6f0e17b 13468 val = read_uleb128 (p, &len, end);
87779176
JM		 13469 p += len;
13470 printf (" Tag_ABI_stack_align_preserved: ");
13471 switch (val)
13472 {
13473 case 0:
13474 printf (_("8-byte\n"));
13475 break;
13476 case 1:
13477 printf (_("16-byte\n"));
13478 break;
13479 default:
13480 printf ("??? (%d)\n", val);
13481 break;
13482 }
13483 return p;
13484
b5593623 13485 case Tag_ABI_DSBT:
f6f0e17b 13486 val = read_uleb128 (p, &len, end);
b5593623
JM		 13487 p += len;
13488 printf (" Tag_ABI_DSBT: ");
13489 switch (val)
13490 {
13491 case 0:
13492 printf (_("DSBT addressing not used\n"));
13493 break;
13494 case 1:
13495 printf (_("DSBT addressing used\n"));
13496 break;
13497 default:
13498 printf ("??? (%d)\n", val);
13499 break;
13500 }
13501 return p;
13502
87779176 13503 case Tag_ABI_PID:
f6f0e17b 13504 val = read_uleb128 (p, &len, end);
87779176
JM		 13505 p += len;
13506 printf (" Tag_ABI_PID: ");
13507 switch (val)
13508 {
13509 case 0:
13510 printf (_("Data addressing position-dependent\n"));
13511 break;
13512 case 1:
13513 printf (_("Data addressing position-independent, GOT near DP\n"));
13514 break;
13515 case 2:
13516 printf (_("Data addressing position-independent, GOT far from DP\n"));
13517 break;
13518 default:
13519 printf ("??? (%d)\n", val);
13520 break;
13521 }
13522 return p;
13523
13524 case Tag_ABI_PIC:
f6f0e17b 13525 val = read_uleb128 (p, &len, end);
87779176
JM		 13526 p += len;
13527 printf (" Tag_ABI_PIC: ");
13528 switch (val)
13529 {
13530 case 0:
13531 printf (_("Code addressing position-dependent\n"));
13532 break;
13533 case 1:
13534 printf (_("Code addressing position-independent\n"));
13535 break;
13536 default:
13537 printf ("??? (%d)\n", val);
13538 break;
13539 }
13540 return p;
13541
13542 case Tag_ABI_array_object_alignment:
f6f0e17b 13543 val = read_uleb128 (p, &len, end);
87779176
JM		 13544 p += len;
13545 printf (" Tag_ABI_array_object_alignment: ");
13546 switch (val)
13547 {
13548 case 0:
13549 printf (_("8-byte\n"));
13550 break;
13551 case 1:
13552 printf (_("4-byte\n"));
13553 break;
13554 case 2:
13555 printf (_("16-byte\n"));
13556 break;
13557 default:
13558 printf ("??? (%d)\n", val);
13559 break;
13560 }
13561 return p;
13562
13563 case Tag_ABI_array_object_align_expected:
f6f0e17b 13564 val = read_uleb128 (p, &len, end);
87779176
JM		 13565 p += len;
13566 printf (" Tag_ABI_array_object_align_expected: ");
13567 switch (val)
13568 {
13569 case 0:
13570 printf (_("8-byte\n"));
13571 break;
13572 case 1:
13573 printf (_("4-byte\n"));
13574 break;
13575 case 2:
13576 printf (_("16-byte\n"));
13577 break;
13578 default:
13579 printf ("??? (%d)\n", val);
13580 break;
13581 }
13582 return p;
13583
3cbd1c06 13584 case Tag_ABI_compatibility:
071436c6 13585 {
071436c6
NC		 13586 val = read_uleb128 (p, &len, end);
13587 p += len;
13588 printf (" Tag_ABI_compatibility: ");
071436c6 13589 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13590 if (p < end - 1)
13591 {
13592 size_t maxlen = (end - p) - 1;
13593
13594 print_symbol ((int) maxlen, (const char *) p);
13595 p += strnlen ((char *) p, maxlen) + 1;
13596 }
13597 else
13598 {
13599 printf (_("<corrupt>"));
13600 p = (unsigned char *) end;
13601 }
071436c6 13602 putchar ('\n');
071436c6
NC		 13603 return p;
13604 }
87779176
JM		 13605
13606 case Tag_ABI_conformance:
071436c6 13607 {
4082ef84
NC		 13608 printf (" Tag_ABI_conformance: \"");
13609 if (p < end - 1)
13610 {
13611 size_t maxlen = (end - p) - 1;
071436c6 13612
4082ef84
NC		 13613 print_symbol ((int) maxlen, (const char *) p);
13614 p += strnlen ((char *) p, maxlen) + 1;
13615 }
13616 else
13617 {
13618 printf (_("<corrupt>"));
13619 p = (unsigned char *) end;
13620 }
071436c6 13621 printf ("\"\n");
071436c6
NC		 13622 return p;
13623 }
59e6276b
JM		 13624 }
13625
f6f0e17b
NC		 13626 return display_tag_value (tag, p, end);
13627}
59e6276b 13628
f6f0e17b
NC		 13629static void
13630display_raw_attribute (unsigned char * p, unsigned char * end)
13631{
13632 unsigned long addr = 0;
13633 size_t bytes = end - p;
13634
e0a31db1 13635 assert (end > p);
f6f0e17b 13636 while (bytes)
87779176 13637 {
f6f0e17b
NC		 13638 int j;
13639 int k;
13640 int lbytes = (bytes > 16 ? 16 : bytes);
13641
13642 printf (" 0x%8.8lx ", addr);
13643
13644 for (j = 0; j < 16; j++)
13645 {
13646 if (j < lbytes)
13647 printf ("%2.2x", p[j]);
13648 else
13649 printf (" ");
13650
13651 if ((j & 3) == 3)
13652 printf (" ");
13653 }
13654
13655 for (j = 0; j < lbytes; j++)
13656 {
13657 k = p[j];
13658 if (k >= ' ' && k < 0x7f)
13659 printf ("%c", k);
13660 else
13661 printf (".");
13662 }
13663
13664 putchar ('\n');
13665
13666 p += lbytes;
13667 bytes -= lbytes;
13668 addr += lbytes;
87779176 13669 }
59e6276b 13670
f6f0e17b 13671 putchar ('\n');
59e6276b
JM		 13672}
13673
13761a11
NC		 13674static unsigned char *
13675display_msp430x_attribute (unsigned char * p,
13676 const unsigned char * const end)
13677{
13678 unsigned int len;
13679 int val;
13680 int tag;
13681
13682 tag = read_uleb128 (p, & len, end);
13683 p += len;
0b4362b0 13684
13761a11
NC		 13685 switch (tag)
13686 {
13687 case OFBA_MSPABI_Tag_ISA:
13688 val = read_uleb128 (p, &len, end);
13689 p += len;
13690 printf (" Tag_ISA: ");
13691 switch (val)
13692 {
13693 case 0: printf (_("None\n")); break;
13694 case 1: printf (_("MSP430\n")); break;
13695 case 2: printf (_("MSP430X\n")); break;
13696 default: printf ("??? (%d)\n", val); break;
13697 }
13698 break;
13699
13700 case OFBA_MSPABI_Tag_Code_Model:
13701 val = read_uleb128 (p, &len, end);
13702 p += len;
13703 printf (" Tag_Code_Model: ");
13704 switch (val)
13705 {
13706 case 0: printf (_("None\n")); break;
13707 case 1: printf (_("Small\n")); break;
13708 case 2: printf (_("Large\n")); break;
13709 default: printf ("??? (%d)\n", val); break;
13710 }
13711 break;
13712
13713 case OFBA_MSPABI_Tag_Data_Model:
13714 val = read_uleb128 (p, &len, end);
13715 p += len;
13716 printf (" Tag_Data_Model: ");
13717 switch (val)
13718 {
13719 case 0: printf (_("None\n")); break;
13720 case 1: printf (_("Small\n")); break;
13721 case 2: printf (_("Large\n")); break;
13722 case 3: printf (_("Restricted Large\n")); break;
13723 default: printf ("??? (%d)\n", val); break;
13724 }
13725 break;
13726
13727 default:
13728 printf (_(" <unknown tag %d>: "), tag);
13729
13730 if (tag & 1)
13731 {
071436c6 13732 putchar ('"');
4082ef84
NC		 13733 if (p < end - 1)
13734 {
13735 size_t maxlen = (end - p) - 1;
13736
13737 print_symbol ((int) maxlen, (const char *) p);
13738 p += strnlen ((char *) p, maxlen) + 1;
13739 }
13740 else
13741 {
13742 printf (_("<corrupt>"));
13743 p = (unsigned char *) end;
13744 }
071436c6 13745 printf ("\"\n");
13761a11
NC		 13746 }
13747 else
13748 {
13749 val = read_uleb128 (p, &len, end);
13750 p += len;
13751 printf ("%d (0x%x)\n", val, val);
13752 }
13753 break;
13754 }
13755
4082ef84 13756 assert (p <= end);
13761a11
NC		 13757 return p;
13758}
13759
11c1ff18 13760static int
60bca95a
NC		 13761process_attributes (FILE * file,
13762 const char * public_name,
104d59d1 13763 unsigned int proc_type,
f6f0e17b
NC		 13764 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13765 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13766{
2cf0635d 13767 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13768 unsigned i;
13769
13770 /* Find the section header so that we get the size. */
13771 for (i = 0, sect = section_headers;
13772 i < elf_header.e_shnum;
13773 i++, sect++)
13774 {
071436c6
NC		 13775 unsigned char * contents;
13776 unsigned char * p;
13777
104d59d1 13778 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13779 continue;
13780
3f5e193b
NC		 13781 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13782 sect->sh_size, _("attributes"));
60bca95a 13783 if (contents == NULL)
11c1ff18 13784 continue;
60bca95a 13785
11c1ff18
PB		 13786 p = contents;
13787 if (*p == 'A')
13788 {
071436c6
NC		 13789 bfd_vma section_len;
13790
13791 section_len = sect->sh_size - 1;
11c1ff18 13792 p++;
60bca95a 13793
071436c6 13794 while (section_len > 0)
11c1ff18 13795 {
071436c6 13796 bfd_vma attr_len;
e9847026 13797 unsigned int namelen;
11c1ff18 13798 bfd_boolean public_section;
104d59d1 13799 bfd_boolean gnu_section;
11c1ff18 13800
071436c6 13801 if (section_len <= 4)
e0a31db1
NC		 13802 {
13803 error (_("Tag section ends prematurely\n"));
13804 break;
13805 }
071436c6 13806 attr_len = byte_get (p, 4);
11c1ff18 13807 p += 4;
60bca95a 13808
071436c6 13809 if (attr_len > section_len)
11c1ff18 13810 {
071436c6
NC		 13811 error (_("Bad attribute length (%u > %u)\n"),
13812 (unsigned) attr_len, (unsigned) section_len);
13813 attr_len = section_len;
11c1ff18 13814 }
74e1a04b 13815 /* PR 17531: file: 001-101425-0.004 */
071436c6 13816 else if (attr_len < 5)
74e1a04b 13817 {
071436c6 13818 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13819 break;
13820 }
e9847026 13821
071436c6
NC		 13822 section_len -= attr_len;
13823 attr_len -= 4;
13824
13825 namelen = strnlen ((char *) p, attr_len) + 1;
13826 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13827 {
13828 error (_("Corrupt attribute section name\n"));
13829 break;
13830 }
13831
071436c6
NC		 13832 printf (_("Attribute Section: "));
13833 print_symbol (INT_MAX, (const char *) p);
13834 putchar ('\n');
60bca95a
NC		 13835
13836 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13837 public_section = TRUE;
13838 else
13839 public_section = FALSE;
60bca95a
NC		 13840
13841 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13842 gnu_section = TRUE;
13843 else
13844 gnu_section = FALSE;
60bca95a 13845
11c1ff18 13846 p += namelen;
071436c6 13847 attr_len -= namelen;
e0a31db1 13848
071436c6 13849 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13850 {
e0a31db1 13851 int tag;
11c1ff18
PB		 13852 int val;
13853 bfd_vma size;
071436c6 13854 unsigned char * end;
60bca95a 13855
e0a31db1 13856 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13857 if (attr_len < 6)
e0a31db1
NC		 13858 {
13859 error (_("Unused bytes at end of section\n"));
13860 section_len = 0;
13861 break;
13862 }
13863
13864 tag = *(p++);
11c1ff18 13865 size = byte_get (p, 4);
071436c6 13866 if (size > attr_len)
11c1ff18 13867 {
e9847026 13868 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13869 (unsigned) size, (unsigned) attr_len);
13870 size = attr_len;
11c1ff18 13871 }
e0a31db1
NC		 13872 /* PR binutils/17531: Safe handling of corrupt files. */
13873 if (size < 6)
13874 {
13875 error (_("Bad subsection length (%u < 6)\n"),
13876 (unsigned) size);
13877 section_len = 0;
13878 break;
13879 }
60bca95a 13880
071436c6 13881 attr_len -= size;
11c1ff18 13882 end = p + size - 1;
071436c6 13883 assert (end <= contents + sect->sh_size);
11c1ff18 13884 p += 4;
60bca95a 13885
11c1ff18
PB		 13886 switch (tag)
13887 {
13888 case 1:
2b692964 13889 printf (_("File Attributes\n"));
11c1ff18
PB		 13890 break;
13891 case 2:
2b692964 13892 printf (_("Section Attributes:"));
11c1ff18
PB		 13893 goto do_numlist;
13894 case 3:
2b692964 13895 printf (_("Symbol Attributes:"));
11c1ff18
PB		 13896 do_numlist:
13897 for (;;)
13898 {
91d6fa6a 13899 unsigned int j;
60bca95a 13900
f6f0e17b 13901 val = read_uleb128 (p, &j, end);
91d6fa6a 13902 p += j;
11c1ff18
PB		 13903 if (val == 0)
13904 break;
13905 printf (" %d", val);
13906 }
13907 printf ("\n");
13908 break;
13909 default:
2b692964 13910 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 13911 public_section = FALSE;
13912 break;
13913 }
60bca95a 13914
071436c6 13915 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 13916 {
13917 while (p < end)
f6f0e17b 13918 p = display_pub_attribute (p, end);
071436c6 13919 assert (p <= end);
104d59d1 13920 }
071436c6 13921 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 13922 {
13923 while (p < end)
13924 p = display_gnu_attribute (p,
f6f0e17b
NC		 13925 display_proc_gnu_attribute,
13926 end);
071436c6 13927 assert (p <= end);
11c1ff18 13928 }
071436c6 13929 else if (p < end)
11c1ff18 13930 {
071436c6 13931 printf (_(" Unknown attribute:\n"));
f6f0e17b 13932 display_raw_attribute (p, end);
11c1ff18
PB		 13933 p = end;
13934 }
071436c6
NC		 13935 else
13936 attr_len = 0;
11c1ff18
PB		 13937 }
13938 }
13939 }
13940 else
e9847026 13941 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 13942
60bca95a 13943 free (contents);
11c1ff18
PB		 13944 }
13945 return 1;
13946}
13947
104d59d1 13948static int
2cf0635d 13949process_arm_specific (FILE * file)
104d59d1
JM		 13950{
13951 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13952 display_arm_attribute, NULL);
13953}
13954
34c8bcba 13955static int
2cf0635d 13956process_power_specific (FILE * file)
34c8bcba
JM		 13957{
13958 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13959 display_power_gnu_attribute);
13960}
13961
643f7afb
AK		 13962static int
13963process_s390_specific (FILE * file)
13964{
13965 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13966 display_s390_gnu_attribute);
13967}
13968
9e8c70f9
DM		 13969static int
13970process_sparc_specific (FILE * file)
13971{
13972 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13973 display_sparc_gnu_attribute);
13974}
13975
59e6276b
JM		 13976static int
13977process_tic6x_specific (FILE * file)
13978{
13979 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13980 display_tic6x_attribute, NULL);
13981}
13982
13761a11
NC		 13983static int
13984process_msp430x_specific (FILE * file)
13985{
13986 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13987 display_msp430x_attribute, NULL);
13988}
13989
ccb4c951
RS		 13990/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13991 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 13992 and return the VMA of the next entry, or -1 if there was a problem.
13993 Does not read from DATA_END or beyond. */
ccb4c951
RS		 13994
13995static bfd_vma
82b1b41b
NC		 13996print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13997 unsigned char * data_end)
ccb4c951
RS		 13998{
13999 printf (" ");
14000 print_vma (addr, LONG_HEX);
14001 printf (" ");
14002 if (addr < pltgot + 0xfff0)
14003 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14004 else
14005 printf ("%10s", "");
14006 printf (" ");
14007 if (data == NULL)
2b692964 14008 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14009 else
14010 {
14011 bfd_vma entry;
82b1b41b 14012 unsigned char * from = data + addr - pltgot;
ccb4c951 14013
82b1b41b
NC		 14014 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14015 {
14016 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14017 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14018 return (bfd_vma) -1;
14019 }
14020 else
14021 {
14022 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14023 print_vma (entry, LONG_HEX);
14024 }
ccb4c951
RS		 14025 }
14026 return addr + (is_32bit_elf ? 4 : 8);
14027}
14028
861fb55a
DJ		 14029/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14030 PLTGOT. Print the Address and Initial fields of an entry at VMA
14031 ADDR and return the VMA of the next entry. */
14032
14033static bfd_vma
2cf0635d 14034print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14035{
14036 printf (" ");
14037 print_vma (addr, LONG_HEX);
14038 printf (" ");
14039 if (data == NULL)
2b692964 14040 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14041 else
14042 {
14043 bfd_vma entry;
14044
14045 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14046 print_vma (entry, LONG_HEX);
14047 }
14048 return addr + (is_32bit_elf ? 4 : 8);
14049}
14050
351cdf24
MF		 14051static void
14052print_mips_ases (unsigned int mask)
14053{
14054 if (mask & AFL_ASE_DSP)
14055 fputs ("\n\tDSP ASE", stdout);
14056 if (mask & AFL_ASE_DSPR2)
14057 fputs ("\n\tDSP R2 ASE", stdout);
14058 if (mask & AFL_ASE_EVA)
14059 fputs ("\n\tEnhanced VA Scheme", stdout);
14060 if (mask & AFL_ASE_MCU)
14061 fputs ("\n\tMCU (MicroController) ASE", stdout);
14062 if (mask & AFL_ASE_MDMX)
14063 fputs ("\n\tMDMX ASE", stdout);
14064 if (mask & AFL_ASE_MIPS3D)
14065 fputs ("\n\tMIPS-3D ASE", stdout);
14066 if (mask & AFL_ASE_MT)
14067 fputs ("\n\tMT ASE", stdout);
14068 if (mask & AFL_ASE_SMARTMIPS)
14069 fputs ("\n\tSmartMIPS ASE", stdout);
14070 if (mask & AFL_ASE_VIRT)
14071 fputs ("\n\tVZ ASE", stdout);
14072 if (mask & AFL_ASE_MSA)
14073 fputs ("\n\tMSA ASE", stdout);
14074 if (mask & AFL_ASE_MIPS16)
14075 fputs ("\n\tMIPS16 ASE", stdout);
14076 if (mask & AFL_ASE_MICROMIPS)
14077 fputs ("\n\tMICROMIPS ASE", stdout);
14078 if (mask & AFL_ASE_XPA)
14079 fputs ("\n\tXPA ASE", stdout);
14080 if (mask == 0)
14081 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14082 else if ((mask & ~AFL_ASE_MASK) != 0)
14083 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14084}
14085
14086static void
14087print_mips_isa_ext (unsigned int isa_ext)
14088{
14089 switch (isa_ext)
14090 {
14091 case 0:
14092 fputs (_("None"), stdout);
14093 break;
14094 case AFL_EXT_XLR:
14095 fputs ("RMI XLR", stdout);
14096 break;
2c629856
N		 14097 case AFL_EXT_OCTEON3:
14098 fputs ("Cavium Networks Octeon3", stdout);
14099 break;
351cdf24
MF		 14100 case AFL_EXT_OCTEON2:
14101 fputs ("Cavium Networks Octeon2", stdout);
14102 break;
14103 case AFL_EXT_OCTEONP:
14104 fputs ("Cavium Networks OcteonP", stdout);
14105 break;
14106 case AFL_EXT_LOONGSON_3A:
14107 fputs ("Loongson 3A", stdout);
14108 break;
14109 case AFL_EXT_OCTEON:
14110 fputs ("Cavium Networks Octeon", stdout);
14111 break;
14112 case AFL_EXT_5900:
14113 fputs ("Toshiba R5900", stdout);
14114 break;
14115 case AFL_EXT_4650:
14116 fputs ("MIPS R4650", stdout);
14117 break;
14118 case AFL_EXT_4010:
14119 fputs ("LSI R4010", stdout);
14120 break;
14121 case AFL_EXT_4100:
14122 fputs ("NEC VR4100", stdout);
14123 break;
14124 case AFL_EXT_3900:
14125 fputs ("Toshiba R3900", stdout);
14126 break;
14127 case AFL_EXT_10000:
14128 fputs ("MIPS R10000", stdout);
14129 break;
14130 case AFL_EXT_SB1:
14131 fputs ("Broadcom SB-1", stdout);
14132 break;
14133 case AFL_EXT_4111:
14134 fputs ("NEC VR4111/VR4181", stdout);
14135 break;
14136 case AFL_EXT_4120:
14137 fputs ("NEC VR4120", stdout);
14138 break;
14139 case AFL_EXT_5400:
14140 fputs ("NEC VR5400", stdout);
14141 break;
14142 case AFL_EXT_5500:
14143 fputs ("NEC VR5500", stdout);
14144 break;
14145 case AFL_EXT_LOONGSON_2E:
14146 fputs ("ST Microelectronics Loongson 2E", stdout);
14147 break;
14148 case AFL_EXT_LOONGSON_2F:
14149 fputs ("ST Microelectronics Loongson 2F", stdout);
14150 break;
14151 default:
00ac7aa0 14152 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14153 }
14154}
14155
14156static int
14157get_mips_reg_size (int reg_size)
14158{
14159 return (reg_size == AFL_REG_NONE) ? 0
14160 : (reg_size == AFL_REG_32) ? 32
14161 : (reg_size == AFL_REG_64) ? 64
14162 : (reg_size == AFL_REG_128) ? 128
14163 : -1;
14164}
14165
19e6b90e 14166static int
2cf0635d 14167process_mips_specific (FILE * file)
5b18a4bc 14168{
2cf0635d 14169 Elf_Internal_Dyn * entry;
351cdf24 14170 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14171 size_t liblist_offset = 0;
14172 size_t liblistno = 0;
14173 size_t conflictsno = 0;
14174 size_t options_offset = 0;
14175 size_t conflicts_offset = 0;
861fb55a
DJ		 14176 size_t pltrelsz = 0;
14177 size_t pltrel = 0;
ccb4c951 14178 bfd_vma pltgot = 0;
861fb55a
DJ		 14179 bfd_vma mips_pltgot = 0;
14180 bfd_vma jmprel = 0;
ccb4c951
RS		 14181 bfd_vma local_gotno = 0;
14182 bfd_vma gotsym = 0;
14183 bfd_vma symtabno = 0;
103f02d3 14184
2cf19d5c
JM		 14185 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14186 display_mips_gnu_attribute);
14187
351cdf24
MF		 14188 sect = find_section (".MIPS.abiflags");
14189
14190 if (sect != NULL)
14191 {
14192 Elf_External_ABIFlags_v0 *abiflags_ext;
14193 Elf_Internal_ABIFlags_v0 abiflags_in;
14194
14195 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14196 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14197 else
14198 {
14199 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14200 sect->sh_size, _("MIPS ABI Flags section"));
14201 if (abiflags_ext)
14202 {
14203 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14204 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14205 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14206 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14207 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14208 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14209 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14210 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14211 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14212 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14213 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14214
14215 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14216 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14217 if (abiflags_in.isa_rev > 1)
14218 printf ("r%d", abiflags_in.isa_rev);
14219 printf ("\nGPR size: %d",
14220 get_mips_reg_size (abiflags_in.gpr_size));
14221 printf ("\nCPR1 size: %d",
14222 get_mips_reg_size (abiflags_in.cpr1_size));
14223 printf ("\nCPR2 size: %d",
14224 get_mips_reg_size (abiflags_in.cpr2_size));
14225 fputs ("\nFP ABI: ", stdout);
14226 print_mips_fp_abi_value (abiflags_in.fp_abi);
14227 fputs ("ISA Extension: ", stdout);
14228 print_mips_isa_ext (abiflags_in.isa_ext);
14229 fputs ("\nASEs:", stdout);
14230 print_mips_ases (abiflags_in.ases);
14231 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14232 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14233 fputc ('\n', stdout);
14234 free (abiflags_ext);
14235 }
14236 }
14237 }
14238
19e6b90e
L		 14239 /* We have a lot of special sections. Thanks SGI! */
14240 if (dynamic_section == NULL)
14241 /* No information available. */
14242 return 0;
252b5132 14243
071436c6
NC		 14244 for (entry = dynamic_section;
14245 /* PR 17531 file: 012-50589-0.004. */
14246 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14247 ++entry)
252b5132
RH		 14248 switch (entry->d_tag)
14249 {
14250 case DT_MIPS_LIBLIST:
d93f0186
NC		 14251 liblist_offset
14252 = offset_from_vma (file, entry->d_un.d_val,
14253 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14254 break;
14255 case DT_MIPS_LIBLISTNO:
14256 liblistno = entry->d_un.d_val;
14257 break;
14258 case DT_MIPS_OPTIONS:
d93f0186 14259 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14260 break;
14261 case DT_MIPS_CONFLICT:
d93f0186
NC		 14262 conflicts_offset
14263 = offset_from_vma (file, entry->d_un.d_val,
14264 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14265 break;
14266 case DT_MIPS_CONFLICTNO:
14267 conflictsno = entry->d_un.d_val;
14268 break;
ccb4c951 14269 case DT_PLTGOT:
861fb55a
DJ		 14270 pltgot = entry->d_un.d_ptr;
14271 break;
ccb4c951
RS		 14272 case DT_MIPS_LOCAL_GOTNO:
14273 local_gotno = entry->d_un.d_val;
14274 break;
14275 case DT_MIPS_GOTSYM:
14276 gotsym = entry->d_un.d_val;
14277 break;
14278 case DT_MIPS_SYMTABNO:
14279 symtabno = entry->d_un.d_val;
14280 break;
861fb55a
DJ		 14281 case DT_MIPS_PLTGOT:
14282 mips_pltgot = entry->d_un.d_ptr;
14283 break;
14284 case DT_PLTREL:
14285 pltrel = entry->d_un.d_val;
14286 break;
14287 case DT_PLTRELSZ:
14288 pltrelsz = entry->d_un.d_val;
14289 break;
14290 case DT_JMPREL:
14291 jmprel = entry->d_un.d_ptr;
14292 break;
252b5132
RH		 14293 default:
14294 break;
14295 }
14296
14297 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14298 {
2cf0635d 14299 Elf32_External_Lib * elib;
252b5132
RH		 14300 size_t cnt;
14301
3f5e193b
NC		 14302 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14303 liblistno,
14304 sizeof (Elf32_External_Lib),
9cf03b7e 14305 _("liblist section data"));
a6e9f9df 14306 if (elib)
252b5132 14307 {
2b692964 14308 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14309 (unsigned long) liblistno);
2b692964 14310 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14311 stdout);
14312
14313 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14314 {
a6e9f9df 14315 Elf32_Lib liblist;
91d6fa6a 14316 time_t atime;
a6e9f9df 14317 char timebuf[20];
2cf0635d 14318 struct tm * tmp;
a6e9f9df
AM		 14319
14320 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14321 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14322 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14323 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14324 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14325
91d6fa6a 14326 tmp = gmtime (&atime);
e9e44622
JJ		 14327 snprintf (timebuf, sizeof (timebuf),
14328 "%04u-%02u-%02uT%02u:%02u:%02u",
14329 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14330 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14331
31104126 14332 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14333 if (VALID_DYNAMIC_NAME (liblist.l_name))
14334 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14335 else
2b692964 14336 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14337 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14338 liblist.l_version);
a6e9f9df
AM		 14339
14340 if (liblist.l_flags == 0)
2b692964 14341 puts (_(" NONE"));
a6e9f9df
AM		 14342 else
14343 {
14344 static const struct
252b5132 14345 {
2cf0635d 14346 const char * name;
a6e9f9df 14347 int bit;
252b5132 14348 }
a6e9f9df
AM		 14349 l_flags_vals[] =
14350 {
14351 { " EXACT_MATCH", LL_EXACT_MATCH },
14352 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14353 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14354 { " EXPORTS", LL_EXPORTS },
14355 { " DELAY_LOAD", LL_DELAY_LOAD },
14356 { " DELTA", LL_DELTA }
14357 };
14358 int flags = liblist.l_flags;
14359 size_t fcnt;
14360
60bca95a 14361 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14362 if ((flags & l_flags_vals[fcnt].bit) != 0)
14363 {
14364 fputs (l_flags_vals[fcnt].name, stdout);
14365 flags ^= l_flags_vals[fcnt].bit;
14366 }
14367 if (flags != 0)
14368 printf (" %#x", (unsigned int) flags);
252b5132 14369
a6e9f9df
AM		 14370 puts ("");
14371 }
252b5132 14372 }
252b5132 14373
a6e9f9df
AM		 14374 free (elib);
14375 }
252b5132
RH		 14376 }
14377
14378 if (options_offset != 0)
14379 {
2cf0635d 14380 Elf_External_Options * eopt;
2cf0635d
NC		 14381 Elf_Internal_Options * iopt;
14382 Elf_Internal_Options * option;
252b5132
RH		 14383 size_t offset;
14384 int cnt;
351cdf24 14385 sect = section_headers;
252b5132
RH		 14386
14387 /* Find the section header so that we get the size. */
071436c6 14388 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14389 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14390 if (sect == NULL)
14391 {
14392 error (_("No MIPS_OPTIONS header found\n"));
14393 return 0;
14394 }
252b5132 14395
3f5e193b
NC		 14396 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14397 sect->sh_size, _("options"));
a6e9f9df 14398 if (eopt)
252b5132 14399 {
3f5e193b
NC		 14400 iopt = (Elf_Internal_Options *)
14401 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14402 if (iopt == NULL)
14403 {
8b73c356 14404 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14405 return 0;
14406 }
76da6bbe 14407
a6e9f9df
AM		 14408 offset = cnt = 0;
14409 option = iopt;
252b5132 14410
82b1b41b 14411 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14412 {
2cf0635d 14413 Elf_External_Options * eoption;
252b5132 14414
a6e9f9df 14415 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14416
a6e9f9df
AM		 14417 option->kind = BYTE_GET (eoption->kind);
14418 option->size = BYTE_GET (eoption->size);
14419 option->section = BYTE_GET (eoption->section);
14420 option->info = BYTE_GET (eoption->info);
76da6bbe 14421
82b1b41b
NC		 14422 /* PR 17531: file: ffa0fa3b. */
14423 if (option->size < sizeof (* eopt)
14424 || offset + option->size > sect->sh_size)
14425 {
55325047
NC		 14426 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14427 return 0;
82b1b41b 14428 }
a6e9f9df 14429 offset += option->size;
14ae95f2 14430
a6e9f9df
AM		 14431 ++option;
14432 ++cnt;
14433 }
252b5132 14434
a6e9f9df 14435 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14436 printable_section_name (sect), cnt);
76da6bbe 14437
a6e9f9df 14438 option = iopt;
82b1b41b 14439 offset = 0;
252b5132 14440
a6e9f9df 14441 while (cnt-- > 0)
252b5132 14442 {
a6e9f9df
AM		 14443 size_t len;
14444
14445 switch (option->kind)
252b5132 14446 {
a6e9f9df
AM		 14447 case ODK_NULL:
14448 /* This shouldn't happen. */
14449 printf (" NULL %d %lx", option->section, option->info);
14450 break;
14451 case ODK_REGINFO:
14452 printf (" REGINFO ");
14453 if (elf_header.e_machine == EM_MIPS)
14454 {
14455 /* 32bit form. */
2cf0635d 14456 Elf32_External_RegInfo * ereg;
b34976b6 14457 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14458
14459 ereg = (Elf32_External_RegInfo *) (option + 1);
14460 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14461 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14462 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14463 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14464 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14465 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14466
14467 printf ("GPR %08lx GP 0x%lx\n",
14468 reginfo.ri_gprmask,
14469 (unsigned long) reginfo.ri_gp_value);
14470 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14471 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14472 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14473 }
14474 else
14475 {
14476 /* 64 bit form. */
2cf0635d 14477 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14478 Elf64_Internal_RegInfo reginfo;
14479
14480 ereg = (Elf64_External_RegInfo *) (option + 1);
14481 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14482 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14483 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14484 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14485 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14486 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14487
14488 printf ("GPR %08lx GP 0x",
14489 reginfo.ri_gprmask);
14490 printf_vma (reginfo.ri_gp_value);
14491 printf ("\n");
14492
14493 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14494 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14495 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14496 }
14497 ++option;
14498 continue;
14499 case ODK_EXCEPTIONS:
14500 fputs (" EXCEPTIONS fpe_min(", stdout);
14501 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14502 fputs (") fpe_max(", stdout);
14503 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14504 fputs (")", stdout);
14505
14506 if (option->info & OEX_PAGE0)
14507 fputs (" PAGE0", stdout);
14508 if (option->info & OEX_SMM)
14509 fputs (" SMM", stdout);
14510 if (option->info & OEX_FPDBUG)
14511 fputs (" FPDBUG", stdout);
14512 if (option->info & OEX_DISMISS)
14513 fputs (" DISMISS", stdout);
14514 break;
14515 case ODK_PAD:
14516 fputs (" PAD ", stdout);
14517 if (option->info & OPAD_PREFIX)
14518 fputs (" PREFIX", stdout);
14519 if (option->info & OPAD_POSTFIX)
14520 fputs (" POSTFIX", stdout);
14521 if (option->info & OPAD_SYMBOL)
14522 fputs (" SYMBOL", stdout);
14523 break;
14524 case ODK_HWPATCH:
14525 fputs (" HWPATCH ", stdout);
14526 if (option->info & OHW_R4KEOP)
14527 fputs (" R4KEOP", stdout);
14528 if (option->info & OHW_R8KPFETCH)
14529 fputs (" R8KPFETCH", stdout);
14530 if (option->info & OHW_R5KEOP)
14531 fputs (" R5KEOP", stdout);
14532 if (option->info & OHW_R5KCVTL)
14533 fputs (" R5KCVTL", stdout);
14534 break;
14535 case ODK_FILL:
14536 fputs (" FILL ", stdout);
14537 /* XXX Print content of info word? */
14538 break;
14539 case ODK_TAGS:
14540 fputs (" TAGS ", stdout);
14541 /* XXX Print content of info word? */
14542 break;
14543 case ODK_HWAND:
14544 fputs (" HWAND ", stdout);
14545 if (option->info & OHWA0_R4KEOP_CHECKED)
14546 fputs (" R4KEOP_CHECKED", stdout);
14547 if (option->info & OHWA0_R4KEOP_CLEAN)
14548 fputs (" R4KEOP_CLEAN", stdout);
14549 break;
14550 case ODK_HWOR:
14551 fputs (" HWOR ", stdout);
14552 if (option->info & OHWA0_R4KEOP_CHECKED)
14553 fputs (" R4KEOP_CHECKED", stdout);
14554 if (option->info & OHWA0_R4KEOP_CLEAN)
14555 fputs (" R4KEOP_CLEAN", stdout);
14556 break;
14557 case ODK_GP_GROUP:
14558 printf (" GP_GROUP %#06lx self-contained %#06lx",
14559 option->info & OGP_GROUP,
14560 (option->info & OGP_SELF) >> 16);
14561 break;
14562 case ODK_IDENT:
14563 printf (" IDENT %#06lx self-contained %#06lx",
14564 option->info & OGP_GROUP,
14565 (option->info & OGP_SELF) >> 16);
14566 break;
14567 default:
14568 /* This shouldn't happen. */
14569 printf (" %3d ??? %d %lx",
14570 option->kind, option->section, option->info);
14571 break;
252b5132 14572 }
a6e9f9df 14573
2cf0635d 14574 len = sizeof (* eopt);
a6e9f9df 14575 while (len < option->size)
82b1b41b 14576 {
7e27a9d5 14577 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14578
82b1b41b
NC		 14579 if (ISPRINT (datum))
14580 printf ("%c", datum);
14581 else
14582 printf ("\\%03o", datum);
14583 len ++;
14584 }
a6e9f9df 14585 fputs ("\n", stdout);
82b1b41b
NC		 14586
14587 offset += option->size;
252b5132 14588 ++option;
252b5132
RH		 14589 }
14590
a6e9f9df 14591 free (eopt);
252b5132 14592 }
252b5132
RH		 14593 }
14594
14595 if (conflicts_offset != 0 && conflictsno != 0)
14596 {
2cf0635d 14597 Elf32_Conflict * iconf;
252b5132
RH		 14598 size_t cnt;
14599
14600 if (dynamic_symbols == NULL)
14601 {
591a748a 14602 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14603 return 0;
14604 }
14605
3f5e193b 14606 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14607 if (iconf == NULL)
14608 {
8b73c356 14609 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14610 return 0;
14611 }
14612
9ea033b2 14613 if (is_32bit_elf)
252b5132 14614 {
2cf0635d 14615 Elf32_External_Conflict * econf32;
a6e9f9df 14616
3f5e193b
NC		 14617 econf32 = (Elf32_External_Conflict *)
14618 get_data (NULL, file, conflicts_offset, conflictsno,
14619 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14620 if (!econf32)
14621 return 0;
252b5132
RH		 14622
14623 for (cnt = 0; cnt < conflictsno; ++cnt)
14624 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14625
14626 free (econf32);
252b5132
RH		 14627 }
14628 else
14629 {
2cf0635d 14630 Elf64_External_Conflict * econf64;
a6e9f9df 14631
3f5e193b
NC		 14632 econf64 = (Elf64_External_Conflict *)
14633 get_data (NULL, file, conflicts_offset, conflictsno,
14634 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14635 if (!econf64)
14636 return 0;
252b5132
RH		 14637
14638 for (cnt = 0; cnt < conflictsno; ++cnt)
14639 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14640
14641 free (econf64);
252b5132
RH		 14642 }
14643
c7e7ca54
NC		 14644 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14645 (unsigned long) conflictsno);
252b5132
RH		 14646 puts (_(" Num: Index Value Name"));
14647
14648 for (cnt = 0; cnt < conflictsno; ++cnt)
14649 {
b34976b6 14650 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14651
14652 if (iconf[cnt] >= num_dynamic_syms)
14653 printf (_("<corrupt symbol index>"));
d79b3d50 14654 else
e0a31db1
NC		 14655 {
14656 Elf_Internal_Sym * psym;
14657
14658 psym = & dynamic_symbols[iconf[cnt]];
14659 print_vma (psym->st_value, FULL_HEX);
14660 putchar (' ');
14661 if (VALID_DYNAMIC_NAME (psym->st_name))
14662 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14663 else
14664 printf (_("<corrupt: %14ld>"), psym->st_name);
14665 }
31104126 14666 putchar ('\n');
252b5132
RH		 14667 }
14668
252b5132
RH		 14669 free (iconf);
14670 }
14671
ccb4c951
RS		 14672 if (pltgot != 0 && local_gotno != 0)
14673 {
91d6fa6a 14674 bfd_vma ent, local_end, global_end;
bbeee7ea 14675 size_t i, offset;
2cf0635d 14676 unsigned char * data;
82b1b41b 14677 unsigned char * data_end;
bbeee7ea 14678 int addr_size;
ccb4c951 14679
91d6fa6a 14680 ent = pltgot;
ccb4c951
RS		 14681 addr_size = (is_32bit_elf ? 4 : 8);
14682 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14683
74e1a04b
NC		 14684 /* PR binutils/17533 file: 012-111227-0.004 */
14685 if (symtabno < gotsym)
14686 {
14687 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14688 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14689 return 0;
14690 }
82b1b41b 14691
74e1a04b 14692 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14693 /* PR 17531: file: 54c91a34. */
14694 if (global_end < local_end)
14695 {
14696 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14697 return 0;
14698 }
948f632f 14699
ccb4c951 14700 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14701 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14702 global_end - pltgot, 1,
14703 _("Global Offset Table data"));
59245841
NC		 14704 if (data == NULL)
14705 return 0;
82b1b41b 14706 data_end = data + (global_end - pltgot);
59245841 14707
ccb4c951
RS		 14708 printf (_("\nPrimary GOT:\n"));
14709 printf (_(" Canonical gp value: "));
14710 print_vma (pltgot + 0x7ff0, LONG_HEX);
14711 printf ("\n\n");
14712
14713 printf (_(" Reserved entries:\n"));
14714 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14715 addr_size * 2, _("Address"), _("Access"),
14716 addr_size * 2, _("Initial"));
82b1b41b 14717 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14718 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14719 if (ent == (bfd_vma) -1)
14720 goto got_print_fail;
ccb4c951 14721 if (data
91d6fa6a 14722 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14723 >> (addr_size * 8 - 1)) != 0)
14724 {
82b1b41b 14725 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14726 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14727 if (ent == (bfd_vma) -1)
14728 goto got_print_fail;
ccb4c951
RS		 14729 }
14730 printf ("\n");
14731
91d6fa6a 14732 if (ent < local_end)
ccb4c951
RS		 14733 {
14734 printf (_(" Local entries:\n"));
cc5914eb 14735 printf (" %*s %10s %*s\n",
2b692964
NC		 14736 addr_size * 2, _("Address"), _("Access"),
14737 addr_size * 2, _("Initial"));
91d6fa6a 14738 while (ent < local_end)
ccb4c951 14739 {
82b1b41b 14740 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14741 printf ("\n");
82b1b41b
NC		 14742 if (ent == (bfd_vma) -1)
14743 goto got_print_fail;
ccb4c951
RS		 14744 }
14745 printf ("\n");
14746 }
14747
14748 if (gotsym < symtabno)
14749 {
14750 int sym_width;
14751
14752 printf (_(" Global entries:\n"));
cc5914eb 14753 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14754 addr_size * 2, _("Address"),
14755 _("Access"),
2b692964 14756 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14757 addr_size * 2, _("Sym.Val."),
14758 _("Type"),
14759 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14760 _("Ndx"), _("Name"));
0b4362b0 14761
ccb4c951 14762 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14763
ccb4c951
RS		 14764 for (i = gotsym; i < symtabno; i++)
14765 {
82b1b41b 14766 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14767 printf (" ");
e0a31db1
NC		 14768
14769 if (dynamic_symbols == NULL)
14770 printf (_("<no dynamic symbols>"));
14771 else if (i < num_dynamic_syms)
14772 {
14773 Elf_Internal_Sym * psym = dynamic_symbols + i;
14774
14775 print_vma (psym->st_value, LONG_HEX);
14776 printf (" %-7s %3s ",
14777 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14778 get_symbol_index_type (psym->st_shndx));
14779
14780 if (VALID_DYNAMIC_NAME (psym->st_name))
14781 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14782 else
14783 printf (_("<corrupt: %14ld>"), psym->st_name);
14784 }
ccb4c951 14785 else
7fc5ac57
JBG		 14786 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14787 (unsigned long) i);
e0a31db1 14788
ccb4c951 14789 printf ("\n");
82b1b41b
NC		 14790 if (ent == (bfd_vma) -1)
14791 break;
ccb4c951
RS		 14792 }
14793 printf ("\n");
14794 }
14795
82b1b41b 14796 got_print_fail:
ccb4c951
RS		 14797 if (data)
14798 free (data);
14799 }
14800
861fb55a
DJ		 14801 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14802 {
91d6fa6a 14803 bfd_vma ent, end;
861fb55a
DJ		 14804 size_t offset, rel_offset;
14805 unsigned long count, i;
2cf0635d 14806 unsigned char * data;
861fb55a 14807 int addr_size, sym_width;
2cf0635d 14808 Elf_Internal_Rela * rels;
861fb55a
DJ		 14809
14810 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14811 if (pltrel == DT_RELA)
14812 {
14813 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14814 return 0;
14815 }
14816 else
14817 {
14818 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14819 return 0;
14820 }
14821
91d6fa6a 14822 ent = mips_pltgot;
861fb55a
DJ		 14823 addr_size = (is_32bit_elf ? 4 : 8);
14824 end = mips_pltgot + (2 + count) * addr_size;
14825
14826 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14827 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14828 1, _("Procedure Linkage Table data"));
59245841
NC		 14829 if (data == NULL)
14830 return 0;
14831
9cf03b7e 14832 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14833 printf (_(" Reserved entries:\n"));
14834 printf (_(" %*s %*s Purpose\n"),
2b692964 14835 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14836 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14837 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14838 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14839 printf (_(" Module pointer\n"));
861fb55a
DJ		 14840 printf ("\n");
14841
14842 printf (_(" Entries:\n"));
cc5914eb 14843 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14844 addr_size * 2, _("Address"),
14845 addr_size * 2, _("Initial"),
14846 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14847 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14848 for (i = 0; i < count; i++)
14849 {
df97ab2a 14850 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14851
91d6fa6a 14852 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14853 printf (" ");
e0a31db1 14854
df97ab2a
MF		 14855 if (idx >= num_dynamic_syms)
14856 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14857 else
e0a31db1 14858 {
df97ab2a 14859 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14860
14861 print_vma (psym->st_value, LONG_HEX);
14862 printf (" %-7s %3s ",
14863 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14864 get_symbol_index_type (psym->st_shndx));
14865 if (VALID_DYNAMIC_NAME (psym->st_name))
14866 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14867 else
14868 printf (_("<corrupt: %14ld>"), psym->st_name);
14869 }
861fb55a
DJ		 14870 printf ("\n");
14871 }
14872 printf ("\n");
14873
14874 if (data)
14875 free (data);
14876 free (rels);
14877 }
14878
252b5132
RH		 14879 return 1;
14880}
14881
35c08157
KLC		 14882static int
14883process_nds32_specific (FILE * file)
14884{
14885 Elf_Internal_Shdr *sect = NULL;
14886
14887 sect = find_section (".nds32_e_flags");
14888 if (sect != NULL)
14889 {
14890 unsigned int *flag;
14891
14892 printf ("\nNDS32 elf flags section:\n");
14893 flag = get_data (NULL, file, sect->sh_offset, 1,
14894 sect->sh_size, _("NDS32 elf flags section"));
14895
14896 switch ((*flag) & 0x3)
14897 {
14898 case 0:
14899 printf ("(VEC_SIZE):\tNo entry.\n");
14900 break;
14901 case 1:
14902 printf ("(VEC_SIZE):\t4 bytes\n");
14903 break;
14904 case 2:
14905 printf ("(VEC_SIZE):\t16 bytes\n");
14906 break;
14907 case 3:
14908 printf ("(VEC_SIZE):\treserved\n");
14909 break;
14910 }
14911 }
14912
14913 return TRUE;
14914}
14915
047b2264 14916static int
2cf0635d 14917process_gnu_liblist (FILE * file)
047b2264 14918{
2cf0635d
NC		 14919 Elf_Internal_Shdr * section;
14920 Elf_Internal_Shdr * string_sec;
14921 Elf32_External_Lib * elib;
14922 char * strtab;
c256ffe7 14923 size_t strtab_size;
047b2264
JJ		 14924 size_t cnt;
14925 unsigned i;
14926
14927 if (! do_arch)
14928 return 0;
14929
14930 for (i = 0, section = section_headers;
14931 i < elf_header.e_shnum;
b34976b6 14932 i++, section++)
047b2264
JJ		 14933 {
14934 switch (section->sh_type)
14935 {
14936 case SHT_GNU_LIBLIST:
4fbb74a6 14937 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 14938 break;
14939
3f5e193b
NC		 14940 elib = (Elf32_External_Lib *)
14941 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 14942 _("liblist section data"));
047b2264
JJ		 14943
14944 if (elib == NULL)
14945 break;
4fbb74a6 14946 string_sec = section_headers + section->sh_link;
047b2264 14947
3f5e193b
NC		 14948 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14949 string_sec->sh_size,
14950 _("liblist string table"));
047b2264
JJ		 14951 if (strtab == NULL
14952 || section->sh_entsize != sizeof (Elf32_External_Lib))
14953 {
14954 free (elib);
2842702f 14955 free (strtab);
047b2264
JJ		 14956 break;
14957 }
59245841 14958 strtab_size = string_sec->sh_size;
047b2264
JJ		 14959
14960 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 14961 printable_section_name (section),
0af1713e 14962 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 14963
2b692964 14964 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 14965
14966 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14967 ++cnt)
14968 {
14969 Elf32_Lib liblist;
91d6fa6a 14970 time_t atime;
047b2264 14971 char timebuf[20];
2cf0635d 14972 struct tm * tmp;
047b2264
JJ		 14973
14974 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14975 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 14976 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14977 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14978 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14979
91d6fa6a 14980 tmp = gmtime (&atime);
e9e44622
JJ		 14981 snprintf (timebuf, sizeof (timebuf),
14982 "%04u-%02u-%02uT%02u:%02u:%02u",
14983 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14984 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 14985
14986 printf ("%3lu: ", (unsigned long) cnt);
14987 if (do_wide)
c256ffe7 14988 printf ("%-20s", liblist.l_name < strtab_size
2b692964 14989 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 14990 else
c256ffe7 14991 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 14992 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 14993 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14994 liblist.l_version, liblist.l_flags);
14995 }
14996
14997 free (elib);
2842702f 14998 free (strtab);
047b2264
JJ		 14999 }
15000 }
15001
15002 return 1;
15003}
15004
9437c45b 15005static const char *
d3ba0551 15006get_note_type (unsigned e_type)
779fe533
NC		 15007{
15008 static char buff[64];
103f02d3 15009
1ec5cd37
NC		 15010 if (elf_header.e_type == ET_CORE)
15011 switch (e_type)
15012 {
57346661 15013 case NT_AUXV:
1ec5cd37 15014 return _("NT_AUXV (auxiliary vector)");
57346661 15015 case NT_PRSTATUS:
1ec5cd37 15016 return _("NT_PRSTATUS (prstatus structure)");
57346661 15017 case NT_FPREGSET:
1ec5cd37 15018 return _("NT_FPREGSET (floating point registers)");
57346661 15019 case NT_PRPSINFO:
1ec5cd37 15020 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15021 case NT_TASKSTRUCT:
1ec5cd37 15022 return _("NT_TASKSTRUCT (task structure)");
57346661 15023 case NT_PRXFPREG:
1ec5cd37 15024 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15025 case NT_PPC_VMX:
15026 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15027 case NT_PPC_VSX:
15028 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15029 case NT_386_TLS:
15030 return _("NT_386_TLS (x86 TLS information)");
15031 case NT_386_IOPERM:
15032 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15033 case NT_X86_XSTATE:
15034 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15035 case NT_S390_HIGH_GPRS:
15036 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15037 case NT_S390_TIMER:
15038 return _("NT_S390_TIMER (s390 timer register)");
15039 case NT_S390_TODCMP:
15040 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15041 case NT_S390_TODPREG:
15042 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15043 case NT_S390_CTRS:
15044 return _("NT_S390_CTRS (s390 control registers)");
15045 case NT_S390_PREFIX:
15046 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15047 case NT_S390_LAST_BREAK:
15048 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15049 case NT_S390_SYSTEM_CALL:
15050 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15051 case NT_S390_TDB:
15052 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15053 case NT_S390_VXRS_LOW:
15054 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15055 case NT_S390_VXRS_HIGH:
15056 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15057 case NT_ARM_VFP:
15058 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15059 case NT_ARM_TLS:
15060 return _("NT_ARM_TLS (AArch TLS registers)");
15061 case NT_ARM_HW_BREAK:
15062 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15063 case NT_ARM_HW_WATCH:
15064 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15065 case NT_PSTATUS:
1ec5cd37 15066 return _("NT_PSTATUS (pstatus structure)");
57346661 15067 case NT_FPREGS:
1ec5cd37 15068 return _("NT_FPREGS (floating point registers)");
57346661 15069 case NT_PSINFO:
1ec5cd37 15070 return _("NT_PSINFO (psinfo structure)");
57346661 15071 case NT_LWPSTATUS:
1ec5cd37 15072 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15073 case NT_LWPSINFO:
1ec5cd37 15074 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15075 case NT_WIN32PSTATUS:
1ec5cd37 15076 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15077 case NT_SIGINFO:
15078 return _("NT_SIGINFO (siginfo_t data)");
15079 case NT_FILE:
15080 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15081 default:
15082 break;
15083 }
15084 else
15085 switch (e_type)
15086 {
15087 case NT_VERSION:
15088 return _("NT_VERSION (version)");
15089 case NT_ARCH:
15090 return _("NT_ARCH (architecture)");
15091 default:
15092 break;
15093 }
15094
e9e44622 15095 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15096 return buff;
779fe533
NC		 15097}
15098
9ece1fa9
TT		 15099static int
15100print_core_note (Elf_Internal_Note *pnote)
15101{
15102 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15103 bfd_vma count, page_size;
15104 unsigned char *descdata, *filenames, *descend;
15105
15106 if (pnote->type != NT_FILE)
15107 return 1;
15108
15109#ifndef BFD64
15110 if (!is_32bit_elf)
15111 {
15112 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15113 /* Still "successful". */
15114 return 1;
15115 }
15116#endif
15117
15118 if (pnote->descsz < 2 * addr_size)
15119 {
15120 printf (_(" Malformed note - too short for header\n"));
15121 return 0;
15122 }
15123
15124 descdata = (unsigned char *) pnote->descdata;
15125 descend = descdata + pnote->descsz;
15126
15127 if (descdata[pnote->descsz - 1] != '\0')
15128 {
15129 printf (_(" Malformed note - does not end with \\0\n"));
15130 return 0;
15131 }
15132
15133 count = byte_get (descdata, addr_size);
15134 descdata += addr_size;
15135
15136 page_size = byte_get (descdata, addr_size);
15137 descdata += addr_size;
15138
15139 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15140 {
15141 printf (_(" Malformed note - too short for supplied file count\n"));
15142 return 0;
15143 }
15144
15145 printf (_(" Page size: "));
15146 print_vma (page_size, DEC);
15147 printf ("\n");
15148
15149 printf (_(" %*s%*s%*s\n"),
15150 (int) (2 + 2 * addr_size), _("Start"),
15151 (int) (4 + 2 * addr_size), _("End"),
15152 (int) (4 + 2 * addr_size), _("Page Offset"));
15153 filenames = descdata + count * 3 * addr_size;
595712bb 15154 while (count-- > 0)
9ece1fa9
TT		 15155 {
15156 bfd_vma start, end, file_ofs;
15157
15158 if (filenames == descend)
15159 {
15160 printf (_(" Malformed note - filenames end too early\n"));
15161 return 0;
15162 }
15163
15164 start = byte_get (descdata, addr_size);
15165 descdata += addr_size;
15166 end = byte_get (descdata, addr_size);
15167 descdata += addr_size;
15168 file_ofs = byte_get (descdata, addr_size);
15169 descdata += addr_size;
15170
15171 printf (" ");
15172 print_vma (start, FULL_HEX);
15173 printf (" ");
15174 print_vma (end, FULL_HEX);
15175 printf (" ");
15176 print_vma (file_ofs, FULL_HEX);
15177 printf ("\n %s\n", filenames);
15178
15179 filenames += 1 + strlen ((char *) filenames);
15180 }
15181
15182 return 1;
15183}
15184
1118d252
RM		 15185static const char *
15186get_gnu_elf_note_type (unsigned e_type)
15187{
15188 static char buff[64];
15189
15190 switch (e_type)
15191 {
15192 case NT_GNU_ABI_TAG:
15193 return _("NT_GNU_ABI_TAG (ABI version tag)");
15194 case NT_GNU_HWCAP:
15195 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15196 case NT_GNU_BUILD_ID:
15197 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15198 case NT_GNU_GOLD_VERSION:
15199 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15200 default:
15201 break;
15202 }
15203
15204 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15205 return buff;
15206}
15207
664f90a3
TT		 15208static int
15209print_gnu_note (Elf_Internal_Note *pnote)
15210{
15211 switch (pnote->type)
15212 {
15213 case NT_GNU_BUILD_ID:
15214 {
15215 unsigned long i;
15216
15217 printf (_(" Build ID: "));
15218 for (i = 0; i < pnote->descsz; ++i)
15219 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15220 printf ("\n");
664f90a3
TT		 15221 }
15222 break;
15223
15224 case NT_GNU_ABI_TAG:
15225 {
15226 unsigned long os, major, minor, subminor;
15227 const char *osname;
15228
3102e897
NC		 15229 /* PR 17531: file: 030-599401-0.004. */
15230 if (pnote->descsz < 16)
15231 {
15232 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15233 break;
15234 }
15235
664f90a3
TT		 15236 os = byte_get ((unsigned char *) pnote->descdata, 4);
15237 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15238 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15239 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15240
15241 switch (os)
15242 {
15243 case GNU_ABI_TAG_LINUX:
15244 osname = "Linux";
15245 break;
15246 case GNU_ABI_TAG_HURD:
15247 osname = "Hurd";
15248 break;
15249 case GNU_ABI_TAG_SOLARIS:
15250 osname = "Solaris";
15251 break;
15252 case GNU_ABI_TAG_FREEBSD:
15253 osname = "FreeBSD";
15254 break;
15255 case GNU_ABI_TAG_NETBSD:
15256 osname = "NetBSD";
15257 break;
14ae95f2
RM		 15258 case GNU_ABI_TAG_SYLLABLE:
15259 osname = "Syllable";
15260 break;
15261 case GNU_ABI_TAG_NACL:
15262 osname = "NaCl";
15263 break;
664f90a3
TT		 15264 default:
15265 osname = "Unknown";
15266 break;
15267 }
15268
15269 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15270 major, minor, subminor);
15271 }
15272 break;
926c5385
CC		 15273
15274 case NT_GNU_GOLD_VERSION:
15275 {
15276 unsigned long i;
15277
15278 printf (_(" Version: "));
15279 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15280 printf ("%c", pnote->descdata[i]);
15281 printf ("\n");
15282 }
15283 break;
664f90a3
TT		 15284 }
15285
15286 return 1;
15287}
15288
685080f2
NC		 15289static const char *
15290get_v850_elf_note_type (enum v850_notes n_type)
15291{
15292 static char buff[64];
15293
15294 switch (n_type)
15295 {
15296 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15297 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15298 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15299 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15300 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15301 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15302 default:
15303 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15304 return buff;
15305 }
15306}
15307
15308static int
15309print_v850_note (Elf_Internal_Note * pnote)
15310{
15311 unsigned int val;
15312
15313 if (pnote->descsz != 4)
15314 return 0;
15315 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15316
15317 if (val == 0)
15318 {
15319 printf (_("not set\n"));
15320 return 1;
15321 }
15322
15323 switch (pnote->type)
15324 {
15325 case V850_NOTE_ALIGNMENT:
15326 switch (val)
15327 {
15328 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15329 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15330 }
15331 break;
14ae95f2 15332
685080f2
NC		 15333 case V850_NOTE_DATA_SIZE:
15334 switch (val)
15335 {
15336 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15337 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15338 }
15339 break;
14ae95f2 15340
685080f2
NC		 15341 case V850_NOTE_FPU_INFO:
15342 switch (val)
15343 {
15344 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15345 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15346 }
15347 break;
14ae95f2 15348
685080f2
NC		 15349 case V850_NOTE_MMU_INFO:
15350 case V850_NOTE_CACHE_INFO:
15351 case V850_NOTE_SIMD_INFO:
15352 if (val == EF_RH850_SIMD)
15353 {
15354 printf (_("yes\n"));
15355 return 1;
15356 }
15357 break;
15358
15359 default:
15360 /* An 'unknown note type' message will already have been displayed. */
15361 break;
15362 }
15363
15364 printf (_("unknown value: %x\n"), val);
15365 return 0;
15366}
15367
9437c45b 15368static const char *
d3ba0551 15369get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15370{
15371 static char buff[64];
15372
b4db1224 15373 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15374 {
15375 /* NetBSD core "procinfo" structure. */
15376 return _("NetBSD procinfo structure");
15377 }
15378
15379 /* As of Jan 2002 there are no other machine-independent notes
15380 defined for NetBSD core files. If the note type is less
15381 than the start of the machine-dependent note types, we don't
15382 understand it. */
15383
b4db1224 15384 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15385 {
e9e44622 15386 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15387 return buff;
15388 }
15389
15390 switch (elf_header.e_machine)
15391 {
15392 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15393 and PT_GETFPREGS == mach+2. */
15394
15395 case EM_OLD_ALPHA:
15396 case EM_ALPHA:
15397 case EM_SPARC:
15398 case EM_SPARC32PLUS:
15399 case EM_SPARCV9:
15400 switch (e_type)
15401 {
2b692964 15402 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15403 return _("PT_GETREGS (reg structure)");
2b692964 15404 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15405 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15406 default:
15407 break;
15408 }
15409 break;
15410
15411 /* On all other arch's, PT_GETREGS == mach+1 and
15412 PT_GETFPREGS == mach+3. */
15413 default:
15414 switch (e_type)
15415 {
2b692964 15416 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15417 return _("PT_GETREGS (reg structure)");
2b692964 15418 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15419 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15420 default:
15421 break;
15422 }
15423 }
15424
9cf03b7e 15425 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15426 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15427 return buff;
15428}
15429
70616151
TT		 15430static const char *
15431get_stapsdt_note_type (unsigned e_type)
15432{
15433 static char buff[64];
15434
15435 switch (e_type)
15436 {
15437 case NT_STAPSDT:
15438 return _("NT_STAPSDT (SystemTap probe descriptors)");
15439
15440 default:
15441 break;
15442 }
15443
15444 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15445 return buff;
15446}
15447
c6a9fc58
TT		 15448static int
15449print_stapsdt_note (Elf_Internal_Note *pnote)
15450{
15451 int addr_size = is_32bit_elf ? 4 : 8;
15452 char *data = pnote->descdata;
15453 char *data_end = pnote->descdata + pnote->descsz;
15454 bfd_vma pc, base_addr, semaphore;
15455 char *provider, *probe, *arg_fmt;
15456
15457 pc = byte_get ((unsigned char *) data, addr_size);
15458 data += addr_size;
15459 base_addr = byte_get ((unsigned char *) data, addr_size);
15460 data += addr_size;
15461 semaphore = byte_get ((unsigned char *) data, addr_size);
15462 data += addr_size;
15463
15464 provider = data;
15465 data += strlen (data) + 1;
15466 probe = data;
15467 data += strlen (data) + 1;
15468 arg_fmt = data;
15469 data += strlen (data) + 1;
15470
15471 printf (_(" Provider: %s\n"), provider);
15472 printf (_(" Name: %s\n"), probe);
15473 printf (_(" Location: "));
15474 print_vma (pc, FULL_HEX);
15475 printf (_(", Base: "));
15476 print_vma (base_addr, FULL_HEX);
15477 printf (_(", Semaphore: "));
15478 print_vma (semaphore, FULL_HEX);
9cf03b7e 15479 printf ("\n");
c6a9fc58
TT		 15480 printf (_(" Arguments: %s\n"), arg_fmt);
15481
15482 return data == data_end;
15483}
15484
00e98fc7
TG		 15485static const char *
15486get_ia64_vms_note_type (unsigned e_type)
15487{
15488 static char buff[64];
15489
15490 switch (e_type)
15491 {
15492 case NT_VMS_MHD:
15493 return _("NT_VMS_MHD (module header)");
15494 case NT_VMS_LNM:
15495 return _("NT_VMS_LNM (language name)");
15496 case NT_VMS_SRC:
15497 return _("NT_VMS_SRC (source files)");
15498 case NT_VMS_TITLE:
9cf03b7e 15499 return "NT_VMS_TITLE";
00e98fc7
TG		 15500 case NT_VMS_EIDC:
15501 return _("NT_VMS_EIDC (consistency check)");
15502 case NT_VMS_FPMODE:
15503 return _("NT_VMS_FPMODE (FP mode)");
15504 case NT_VMS_LINKTIME:
9cf03b7e 15505 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15506 case NT_VMS_IMGNAM:
15507 return _("NT_VMS_IMGNAM (image name)");
15508 case NT_VMS_IMGID:
15509 return _("NT_VMS_IMGID (image id)");
15510 case NT_VMS_LINKID:
15511 return _("NT_VMS_LINKID (link id)");
15512 case NT_VMS_IMGBID:
15513 return _("NT_VMS_IMGBID (build id)");
15514 case NT_VMS_GSTNAM:
15515 return _("NT_VMS_GSTNAM (sym table name)");
15516 case NT_VMS_ORIG_DYN:
9cf03b7e 15517 return "NT_VMS_ORIG_DYN";
00e98fc7 15518 case NT_VMS_PATCHTIME:
9cf03b7e 15519 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15520 default:
15521 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15522 return buff;
15523 }
15524}
15525
15526static int
15527print_ia64_vms_note (Elf_Internal_Note * pnote)
15528{
15529 switch (pnote->type)
15530 {
15531 case NT_VMS_MHD:
15532 if (pnote->descsz > 36)
15533 {
15534 size_t l = strlen (pnote->descdata + 34);
15535 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15536 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15537 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15538 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15539 }
15540 else
15541 printf (_(" Invalid size\n"));
15542 break;
15543 case NT_VMS_LNM:
15544 printf (_(" Language: %s\n"), pnote->descdata);
15545 break;
15546#ifdef BFD64
15547 case NT_VMS_FPMODE:
9cf03b7e 15548 printf (_(" Floating Point mode: "));
4a5cb34f 15549 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15550 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15551 break;
15552 case NT_VMS_LINKTIME:
15553 printf (_(" Link time: "));
15554 print_vms_time
15555 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15556 printf ("\n");
15557 break;
15558 case NT_VMS_PATCHTIME:
15559 printf (_(" Patch 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_ORIG_DYN:
15565 printf (_(" Major id: %u, minor id: %u\n"),
15566 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15567 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15568 printf (_(" Last modified : "));
00e98fc7
TG		 15569 print_vms_time
15570 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15571 printf (_("\n Link flags : "));
4a5cb34f 15572 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15573 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15574 printf (_(" Header flags: 0x%08x\n"),
948f632f 15575 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15576 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15577 break;
15578#endif
15579 case NT_VMS_IMGNAM:
15580 printf (_(" Image name: %s\n"), pnote->descdata);
15581 break;
15582 case NT_VMS_GSTNAM:
15583 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15584 break;
15585 case NT_VMS_IMGID:
15586 printf (_(" Image id: %s\n"), pnote->descdata);
15587 break;
15588 case NT_VMS_LINKID:
15589 printf (_(" Linker id: %s\n"), pnote->descdata);
15590 break;
15591 default:
15592 break;
15593 }
15594 return 1;
15595}
15596
6d118b09
NC		 15597/* Note that by the ELF standard, the name field is already null byte
15598 terminated, and namesz includes the terminating null byte.
15599 I.E. the value of namesz for the name "FSF" is 4.
15600
e3c8793a 15601 If the value of namesz is zero, there is no name present. */
779fe533 15602static int
2cf0635d 15603process_note (Elf_Internal_Note * pnote)
779fe533 15604{
2cf0635d
NC		 15605 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15606 const char * nt;
9437c45b
JT		 15607
15608 if (pnote->namesz == 0)
1ec5cd37
NC		 15609 /* If there is no note name, then use the default set of
15610 note type strings. */
15611 nt = get_note_type (pnote->type);
15612
1118d252
RM		 15613 else if (const_strneq (pnote->namedata, "GNU"))
15614 /* GNU-specific object file notes. */
15615 nt = get_gnu_elf_note_type (pnote->type);
15616
0112cd26 15617 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15618 /* NetBSD-specific core file notes. */
15619 nt = get_netbsd_elfcore_note_type (pnote->type);
15620
b15fa79e
AM		 15621 else if (strneq (pnote->namedata, "SPU/", 4))
15622 {
15623 /* SPU-specific core file notes. */
15624 nt = pnote->namedata + 4;
15625 name = "SPU";
15626 }
15627
00e98fc7
TG		 15628 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15629 /* VMS/ia64-specific file notes. */
15630 nt = get_ia64_vms_note_type (pnote->type);
15631
70616151
TT		 15632 else if (const_strneq (pnote->namedata, "stapsdt"))
15633 nt = get_stapsdt_note_type (pnote->type);
15634
9437c45b 15635 else
1ec5cd37
NC		 15636 /* Don't recognize this note name; just use the default set of
15637 note type strings. */
00e98fc7 15638 nt = get_note_type (pnote->type);
9437c45b 15639
2aee03ae 15640 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15641
15642 if (const_strneq (pnote->namedata, "IPF/VMS"))
15643 return print_ia64_vms_note (pnote);
664f90a3
TT		 15644 else if (const_strneq (pnote->namedata, "GNU"))
15645 return print_gnu_note (pnote);
c6a9fc58
TT		 15646 else if (const_strneq (pnote->namedata, "stapsdt"))
15647 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15648 else if (const_strneq (pnote->namedata, "CORE"))
15649 return print_core_note (pnote);
00e98fc7
TG		 15650 else
15651 return 1;
779fe533
NC		 15652}
15653
6d118b09 15654
779fe533 15655static int
2cf0635d 15656process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15657{
2cf0635d
NC		 15658 Elf_External_Note * pnotes;
15659 Elf_External_Note * external;
c8071705 15660 char * end;
b34976b6 15661 int res = 1;
103f02d3 15662
779fe533
NC		 15663 if (length <= 0)
15664 return 0;
103f02d3 15665
3f5e193b 15666 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15667 _("notes"));
dd24e3da 15668 if (pnotes == NULL)
a6e9f9df 15669 return 0;
779fe533 15670
103f02d3 15671 external = pnotes;
103f02d3 15672
9dd3a467 15673 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15674 (unsigned long) offset, (unsigned long) length);
2aee03ae 15675 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15676
c8071705
NC		 15677 end = (char *) pnotes + length;
15678 while ((char *) external < end)
779fe533 15679 {
b34976b6 15680 Elf_Internal_Note inote;
15b42fb0
AM		 15681 size_t min_notesz;
15682 char *next;
2cf0635d 15683 char * temp = NULL;
c8071705 15684 size_t data_remaining = end - (char *) external;
6d118b09 15685
00e98fc7 15686 if (!is_ia64_vms ())
15b42fb0 15687 {
9dd3a467
NC		 15688 /* PR binutils/15191
15689 Make sure that there is enough data to read. */
15b42fb0
AM		 15690 min_notesz = offsetof (Elf_External_Note, name);
15691 if (data_remaining < min_notesz)
9dd3a467
NC		 15692 {
15693 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15694 (int) data_remaining);
15695 break;
15696 }
15b42fb0
AM		 15697 inote.type = BYTE_GET (external->type);
15698 inote.namesz = BYTE_GET (external->namesz);
15699 inote.namedata = external->name;
15700 inote.descsz = BYTE_GET (external->descsz);
15701 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15702 /* PR 17531: file: 3443835e. */
c8071705 15703 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15704 {
15705 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15706 inote.descdata = inote.namedata;
15707 inote.namesz = 0;
15708 }
14ae95f2 15709
15b42fb0
AM		 15710 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15711 next = inote.descdata + align_power (inote.descsz, 2);
15712 }
00e98fc7 15713 else
15b42fb0
AM		 15714 {
15715 Elf64_External_VMS_Note *vms_external;
00e98fc7 15716
9dd3a467
NC		 15717 /* PR binutils/15191
15718 Make sure that there is enough data to read. */
15b42fb0
AM		 15719 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15720 if (data_remaining < min_notesz)
9dd3a467
NC		 15721 {
15722 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15723 (int) data_remaining);
15724 break;
15725 }
3e55a963 15726
15b42fb0
AM		 15727 vms_external = (Elf64_External_VMS_Note *) external;
15728 inote.type = BYTE_GET (vms_external->type);
15729 inote.namesz = BYTE_GET (vms_external->namesz);
15730 inote.namedata = vms_external->name;
15731 inote.descsz = BYTE_GET (vms_external->descsz);
15732 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15733 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15734 next = inote.descdata + align_power (inote.descsz, 3);
15735 }
15736
15737 if (inote.descdata < (char *) external + min_notesz
15738 || next < (char *) external + min_notesz
5d921cbd
NC		 15739 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15740 || inote.namedata + inote.namesz < inote.namedata
15741 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15742 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15743 {
15b42fb0 15744 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15745 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15746 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15747 inote.type, inote.namesz, inote.descsz);
15748 break;
15749 }
15750
15b42fb0 15751 external = (Elf_External_Note *) next;
dd24e3da 15752
6d118b09
NC		 15753 /* Verify that name is null terminated. It appears that at least
15754 one version of Linux (RedHat 6.0) generates corefiles that don't
15755 comply with the ELF spec by failing to include the null byte in
15756 namesz. */
8b971f9f 15757 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15758 {
3f5e193b 15759 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15760 if (temp == NULL)
15761 {
8b73c356 15762 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15763 res = 0;
15764 break;
15765 }
76da6bbe 15766
6d118b09
NC		 15767 strncpy (temp, inote.namedata, inote.namesz);
15768 temp[inote.namesz] = 0;
76da6bbe 15769
6d118b09
NC		 15770 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15771 inote.namedata = temp;
15772 }
15773
15774 res &= process_note (& inote);
103f02d3 15775
6d118b09
NC		 15776 if (temp != NULL)
15777 {
15778 free (temp);
15779 temp = NULL;
15780 }
779fe533
NC		 15781 }
15782
15783 free (pnotes);
103f02d3 15784
779fe533
NC		 15785 return res;
15786}
15787
15788static int
2cf0635d 15789process_corefile_note_segments (FILE * file)
779fe533 15790{
2cf0635d 15791 Elf_Internal_Phdr * segment;
b34976b6
AM		 15792 unsigned int i;
15793 int res = 1;
103f02d3 15794
d93f0186 15795 if (! get_program_headers (file))
779fe533 15796 return 0;
103f02d3 15797
779fe533
NC		 15798 for (i = 0, segment = program_headers;
15799 i < elf_header.e_phnum;
b34976b6 15800 i++, segment++)
779fe533
NC		 15801 {
15802 if (segment->p_type == PT_NOTE)
103f02d3 15803 res &= process_corefile_note_segment (file,
30800947
NC		 15804 (bfd_vma) segment->p_offset,
15805 (bfd_vma) segment->p_filesz);
779fe533 15806 }
103f02d3 15807
779fe533
NC		 15808 return res;
15809}
15810
685080f2
NC		 15811static int
15812process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
15813{
15814 Elf_External_Note * pnotes;
15815 Elf_External_Note * external;
c8071705 15816 char * end;
685080f2
NC		 15817 int res = 1;
15818
15819 if (length <= 0)
15820 return 0;
15821
15822 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15823 _("v850 notes"));
15824 if (pnotes == NULL)
15825 return 0;
15826
15827 external = pnotes;
c8071705 15828 end = (char*) pnotes + length;
685080f2
NC		 15829
15830 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15831 (unsigned long) offset, (unsigned long) length);
15832
c8071705 15833 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 15834 {
15835 Elf_External_Note * next;
15836 Elf_Internal_Note inote;
15837
15838 inote.type = BYTE_GET (external->type);
15839 inote.namesz = BYTE_GET (external->namesz);
15840 inote.namedata = external->name;
15841 inote.descsz = BYTE_GET (external->descsz);
15842 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15843 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15844
c8071705
NC		 15845 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
15846 {
15847 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15848 inote.descdata = inote.namedata;
15849 inote.namesz = 0;
15850 }
15851
685080f2
NC		 15852 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
15853
c8071705 15854 if ( ((char *) next > end)
685080f2
NC		 15855 || ((char *) next < (char *) pnotes))
15856 {
15857 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15858 (unsigned long) ((char *) external - (char *) pnotes));
15859 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15860 inote.type, inote.namesz, inote.descsz);
15861 break;
15862 }
15863
15864 external = next;
15865
15866 /* Prevent out-of-bounds indexing. */
c8071705 15867 if ( inote.namedata + inote.namesz > end
685080f2
NC		 15868 || inote.namedata + inote.namesz < inote.namedata)
15869 {
15870 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15871 (unsigned long) ((char *) external - (char *) pnotes));
15872 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15873 inote.type, inote.namesz, inote.descsz);
15874 break;
15875 }
15876
15877 printf (" %s: ", get_v850_elf_note_type (inote.type));
15878
15879 if (! print_v850_note (& inote))
15880 {
15881 res = 0;
15882 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15883 inote.namesz, inote.descsz);
15884 }
15885 }
15886
15887 free (pnotes);
15888
15889 return res;
15890}
15891
779fe533 15892static int
2cf0635d 15893process_note_sections (FILE * file)
1ec5cd37 15894{
2cf0635d 15895 Elf_Internal_Shdr * section;
1ec5cd37 15896 unsigned long i;
df565f32 15897 int n = 0;
1ec5cd37
NC		 15898 int res = 1;
15899
15900 for (i = 0, section = section_headers;
fa1908fd 15901 i < elf_header.e_shnum && section != NULL;
1ec5cd37 15902 i++, section++)
685080f2
NC		 15903 {
15904 if (section->sh_type == SHT_NOTE)
15905 {
15906 res &= process_corefile_note_segment (file,
15907 (bfd_vma) section->sh_offset,
15908 (bfd_vma) section->sh_size);
15909 n++;
15910 }
15911
15912 if (( elf_header.e_machine == EM_V800
15913 || elf_header.e_machine == EM_V850
15914 || elf_header.e_machine == EM_CYGNUS_V850)
15915 && section->sh_type == SHT_RENESAS_INFO)
15916 {
15917 res &= process_v850_notes (file,
15918 (bfd_vma) section->sh_offset,
15919 (bfd_vma) section->sh_size);
15920 n++;
15921 }
15922 }
df565f32
NC		 15923
15924 if (n == 0)
15925 /* Try processing NOTE segments instead. */
15926 return process_corefile_note_segments (file);
1ec5cd37
NC		 15927
15928 return res;
15929}
15930
15931static int
2cf0635d 15932process_notes (FILE * file)
779fe533
NC		 15933{
15934 /* If we have not been asked to display the notes then do nothing. */
15935 if (! do_notes)
15936 return 1;
103f02d3 15937
779fe533 15938 if (elf_header.e_type != ET_CORE)
1ec5cd37 15939 return process_note_sections (file);
103f02d3 15940
779fe533 15941 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 15942 if (elf_header.e_phnum > 0)
15943 return process_corefile_note_segments (file);
779fe533 15944
1ec5cd37
NC		 15945 printf (_("No note segments present in the core file.\n"));
15946 return 1;
779fe533
NC		 15947}
15948
252b5132 15949static int
2cf0635d 15950process_arch_specific (FILE * file)
252b5132 15951{
a952a375
NC		 15952 if (! do_arch)
15953 return 1;
15954
252b5132
RH		 15955 switch (elf_header.e_machine)
15956 {
11c1ff18
PB		 15957 case EM_ARM:
15958 return process_arm_specific (file);
252b5132 15959 case EM_MIPS:
4fe85591 15960 case EM_MIPS_RS3_LE:
252b5132
RH		 15961 return process_mips_specific (file);
15962 break;
35c08157
KLC		 15963 case EM_NDS32:
15964 return process_nds32_specific (file);
15965 break;
34c8bcba
JM		 15966 case EM_PPC:
15967 return process_power_specific (file);
15968 break;
643f7afb
AK		 15969 case EM_S390:
15970 case EM_S390_OLD:
15971 return process_s390_specific (file);
15972 break;
9e8c70f9
DM		 15973 case EM_SPARC:
15974 case EM_SPARC32PLUS:
15975 case EM_SPARCV9:
15976 return process_sparc_specific (file);
15977 break;
59e6276b
JM		 15978 case EM_TI_C6000:
15979 return process_tic6x_specific (file);
15980 break;
13761a11
NC		 15981 case EM_MSP430:
15982 return process_msp430x_specific (file);
252b5132
RH		 15983 default:
15984 break;
15985 }
15986 return 1;
15987}
15988
15989static int
2cf0635d 15990get_file_header (FILE * file)
252b5132 15991{
9ea033b2
NC		 15992 /* Read in the identity array. */
15993 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 15994 return 0;
15995
9ea033b2 15996 /* Determine how to read the rest of the header. */
b34976b6 15997 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 15998 {
15999 default: /* fall through */
16000 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16001 case ELFDATA2LSB:
16002 byte_get = byte_get_little_endian;
16003 byte_put = byte_put_little_endian;
16004 break;
16005 case ELFDATA2MSB:
16006 byte_get = byte_get_big_endian;
16007 byte_put = byte_put_big_endian;
16008 break;
9ea033b2
NC		 16009 }
16010
16011 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16012 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16013
16014 /* Read in the rest of the header. */
16015 if (is_32bit_elf)
16016 {
16017 Elf32_External_Ehdr ehdr32;
252b5132 16018
9ea033b2
NC		 16019 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16020 return 0;
103f02d3 16021
9ea033b2
NC		 16022 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16023 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16024 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16025 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16026 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16027 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16028 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16029 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16030 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16031 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16032 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16033 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16034 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16035 }
252b5132 16036 else
9ea033b2
NC		 16037 {
16038 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16039
16040 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16041 we will not be able to cope with the 64bit data found in
16042 64 ELF files. Detect this now and abort before we start
50c2245b 16043 overwriting things. */
a952a375
NC		 16044 if (sizeof (bfd_vma) < 8)
16045 {
e3c8793a
NC		 16046 error (_("This instance of readelf has been built without support for a\n\
1604764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16048 return 0;
16049 }
103f02d3 16050
9ea033b2
NC		 16051 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16052 return 0;
103f02d3 16053
9ea033b2
NC		 16054 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16055 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16056 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16057 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16058 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16059 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16060 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16061 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16062 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16063 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16064 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16065 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16066 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16067 }
252b5132 16068
7ece0d85
JJ		 16069 if (elf_header.e_shoff)
16070 {
16071 /* There may be some extensions in the first section header. Don't
16072 bomb if we can't read it. */
16073 if (is_32bit_elf)
049b0c3a 16074 get_32bit_section_headers (file, TRUE);
7ece0d85 16075 else
049b0c3a 16076 get_64bit_section_headers (file, TRUE);
7ece0d85 16077 }
560f3c1c 16078
252b5132
RH		 16079 return 1;
16080}
16081
fb52b2f4
NC		 16082/* Process one ELF object file according to the command line options.
16083 This file may actually be stored in an archive. The file is
16084 positioned at the start of the ELF object. */
16085
ff78d6d6 16086static int
2cf0635d 16087process_object (char * file_name, FILE * file)
252b5132 16088{
252b5132
RH		 16089 unsigned int i;
16090
252b5132
RH		 16091 if (! get_file_header (file))
16092 {
16093 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16094 return 1;
252b5132
RH		 16095 }
16096
16097 /* Initialise per file variables. */
60bca95a 16098 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16099 version_info[i] = 0;
16100
60bca95a 16101 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16102 dynamic_info[i] = 0;
5115b233 16103 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16104
16105 /* Process the file. */
16106 if (show_name)
16107 printf (_("\nFile: %s\n"), file_name);
16108
18bd398b
NC		 16109 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16110 Note we do this even if cmdline_dump_sects is empty because we
16111 must make sure that the dump_sets array is zeroed out before each
16112 object file is processed. */
16113 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16114 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16115
16116 if (num_cmdline_dump_sects > 0)
16117 {
16118 if (num_dump_sects == 0)
16119 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16120 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16121
16122 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16123 memcpy (dump_sects, cmdline_dump_sects,
16124 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16125 }
d70c5fc7 16126
252b5132 16127 if (! process_file_header ())
fb52b2f4 16128 return 1;
252b5132 16129
d1f5c6e3 16130 if (! process_section_headers (file))
2f62977e 16131 {
d1f5c6e3
L		 16132 /* Without loaded section headers we cannot process lots of
16133 things. */
2f62977e 16134 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16135
2f62977e 16136 if (! do_using_dynamic)
2c610e4b 16137 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16138 }
252b5132 16139
d1f5c6e3
L		 16140 if (! process_section_groups (file))
16141 {
16142 /* Without loaded section groups we cannot process unwind. */
16143 do_unwind = 0;
16144 }
16145
2f62977e 16146 if (process_program_headers (file))
b2d38a17 16147 process_dynamic_section (file);
252b5132
RH		 16148
16149 process_relocs (file);
16150
4d6ed7c8
NC		 16151 process_unwind (file);
16152
252b5132
RH		 16153 process_symbol_table (file);
16154
16155 process_syminfo (file);
16156
16157 process_version_sections (file);
16158
16159 process_section_contents (file);
f5842774 16160
1ec5cd37 16161 process_notes (file);
103f02d3 16162
047b2264
JJ		 16163 process_gnu_liblist (file);
16164
252b5132
RH		 16165 process_arch_specific (file);
16166
d93f0186
NC		 16167 if (program_headers)
16168 {
16169 free (program_headers);
16170 program_headers = NULL;
16171 }
16172
252b5132
RH		 16173 if (section_headers)
16174 {
16175 free (section_headers);
16176 section_headers = NULL;
16177 }
16178
16179 if (string_table)
16180 {
16181 free (string_table);
16182 string_table = NULL;
d40ac9bd 16183 string_table_length = 0;
252b5132
RH		 16184 }
16185
16186 if (dynamic_strings)
16187 {
16188 free (dynamic_strings);
16189 dynamic_strings = NULL;
d79b3d50 16190 dynamic_strings_length = 0;
252b5132
RH		 16191 }
16192
16193 if (dynamic_symbols)
16194 {
16195 free (dynamic_symbols);
16196 dynamic_symbols = NULL;
19936277 16197 num_dynamic_syms = 0;
252b5132
RH		 16198 }
16199
16200 if (dynamic_syminfo)
16201 {
16202 free (dynamic_syminfo);
16203 dynamic_syminfo = NULL;
16204 }
ff78d6d6 16205
293c573e
MR		 16206 if (dynamic_section)
16207 {
16208 free (dynamic_section);
16209 dynamic_section = NULL;
16210 }
16211
e4b17d5c
L		 16212 if (section_headers_groups)
16213 {
16214 free (section_headers_groups);
16215 section_headers_groups = NULL;
16216 }
16217
16218 if (section_groups)
16219 {
2cf0635d
NC		 16220 struct group_list * g;
16221 struct group_list * next;
e4b17d5c
L		 16222
16223 for (i = 0; i < group_count; i++)
16224 {
16225 for (g = section_groups [i].root; g != NULL; g = next)
16226 {
16227 next = g->next;
16228 free (g);
16229 }
16230 }
16231
16232 free (section_groups);
16233 section_groups = NULL;
16234 }
16235
19e6b90e 16236 free_debug_memory ();
18bd398b 16237
ff78d6d6 16238 return 0;
252b5132
RH		 16239}
16240
2cf0635d
NC		 16241/* Process an ELF archive.
16242 On entry the file is positioned just after the ARMAG string. */
16243
16244static int
16245process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16246{
16247 struct archive_info arch;
16248 struct archive_info nested_arch;
16249 size_t got;
2cf0635d
NC		 16250 int ret;
16251
16252 show_name = 1;
16253
16254 /* The ARCH structure is used to hold information about this archive. */
16255 arch.file_name = NULL;
16256 arch.file = NULL;
16257 arch.index_array = NULL;
16258 arch.sym_table = NULL;
16259 arch.longnames = NULL;
16260
16261 /* The NESTED_ARCH structure is used as a single-item cache of information
16262 about a nested archive (when members of a thin archive reside within
16263 another regular archive file). */
16264 nested_arch.file_name = NULL;
16265 nested_arch.file = NULL;
16266 nested_arch.index_array = NULL;
16267 nested_arch.sym_table = NULL;
16268 nested_arch.longnames = NULL;
16269
16270 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16271 {
16272 ret = 1;
16273 goto out;
4145f1d5 16274 }
fb52b2f4 16275
4145f1d5
NC		 16276 if (do_archive_index)
16277 {
2cf0635d 16278 if (arch.sym_table == NULL)
4145f1d5
NC		 16279 error (_("%s: unable to dump the index as none was found\n"), file_name);
16280 else
16281 {
591f7597 16282 unsigned long i, l;
4145f1d5
NC		 16283 unsigned long current_pos;
16284
591f7597
NC		 16285 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16286 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16287 current_pos = ftell (file);
16288
2cf0635d 16289 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16290 {
2cf0635d
NC		 16291 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16292 {
16293 char * member_name;
4145f1d5 16294
2cf0635d
NC		 16295 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16296
16297 if (member_name != NULL)
16298 {
16299 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16300
16301 if (qualified_name != NULL)
16302 {
c2a7d3f5
NC		 16303 printf (_("Contents of binary %s at offset "), qualified_name);
16304 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16305 putchar ('\n');
2cf0635d
NC		 16306 free (qualified_name);
16307 }
4145f1d5
NC		 16308 }
16309 }
2cf0635d
NC		 16310
16311 if (l >= arch.sym_size)
4145f1d5
NC		 16312 {
16313 error (_("%s: end of the symbol table reached before the end of the index\n"),
16314 file_name);
cb8f3167 16315 break;
4145f1d5 16316 }
591f7597
NC		 16317 /* PR 17531: file: 0b6630b2. */
16318 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16319 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16320 }
16321
c2a7d3f5
NC		 16322 if (arch.uses_64bit_indicies)
16323 l = (l + 7) & ~ 7;
16324 else
16325 l += l & 1;
16326
2cf0635d 16327 if (l < arch.sym_size)
c2a7d3f5
NC		 16328 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16329 file_name, arch.sym_size - l);
4145f1d5 16330
4145f1d5
NC		 16331 if (fseek (file, current_pos, SEEK_SET) != 0)
16332 {
16333 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16334 ret = 1;
16335 goto out;
4145f1d5 16336 }
fb52b2f4 16337 }
4145f1d5
NC		 16338
16339 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16340 && !do_segments && !do_header && !do_dump && !do_version
16341 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16342 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16343 {
16344 ret = 0; /* Archive index only. */
16345 goto out;
16346 }
fb52b2f4
NC		 16347 }
16348
d989285c 16349 ret = 0;
fb52b2f4
NC		 16350
16351 while (1)
16352 {
2cf0635d
NC		 16353 char * name;
16354 size_t namelen;
16355 char * qualified_name;
16356
16357 /* Read the next archive header. */
16358 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16359 {
16360 error (_("%s: failed to seek to next archive header\n"), file_name);
16361 return 1;
16362 }
16363 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16364 if (got != sizeof arch.arhdr)
16365 {
16366 if (got == 0)
16367 break;
16368 error (_("%s: failed to read archive header\n"), file_name);
16369 ret = 1;
16370 break;
16371 }
16372 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16373 {
16374 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16375 ret = 1;
16376 break;
16377 }
16378
16379 arch.next_arhdr_offset += sizeof arch.arhdr;
16380
16381 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16382 if (archive_file_size & 01)
16383 ++archive_file_size;
16384
16385 name = get_archive_member_name (&arch, &nested_arch);
16386 if (name == NULL)
fb52b2f4 16387 {
0fd3a477 16388 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16389 ret = 1;
16390 break;
fb52b2f4 16391 }
2cf0635d 16392 namelen = strlen (name);
fb52b2f4 16393
2cf0635d
NC		 16394 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16395 if (qualified_name == NULL)
fb52b2f4 16396 {
2cf0635d 16397 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16398 ret = 1;
16399 break;
fb52b2f4
NC		 16400 }
16401
2cf0635d
NC		 16402 if (is_thin_archive && arch.nested_member_origin == 0)
16403 {
16404 /* This is a proxy for an external member of a thin archive. */
16405 FILE * member_file;
16406 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16407 if (member_file_name == NULL)
16408 {
16409 ret = 1;
16410 break;
16411 }
16412
16413 member_file = fopen (member_file_name, "rb");
16414 if (member_file == NULL)
16415 {
16416 error (_("Input file '%s' is not readable.\n"), member_file_name);
16417 free (member_file_name);
16418 ret = 1;
16419 break;
16420 }
16421
16422 archive_file_offset = arch.nested_member_origin;
16423
16424 ret |= process_object (qualified_name, member_file);
16425
16426 fclose (member_file);
16427 free (member_file_name);
16428 }
16429 else if (is_thin_archive)
16430 {
a043396b
NC		 16431 /* PR 15140: Allow for corrupt thin archives. */
16432 if (nested_arch.file == NULL)
16433 {
16434 error (_("%s: contains corrupt thin archive: %s\n"),
16435 file_name, name);
16436 ret = 1;
16437 break;
16438 }
16439
2cf0635d
NC		 16440 /* This is a proxy for a member of a nested archive. */
16441 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16442
16443 /* The nested archive file will have been opened and setup by
16444 get_archive_member_name. */
16445 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16446 {
16447 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16448 ret = 1;
16449 break;
16450 }
16451
16452 ret |= process_object (qualified_name, nested_arch.file);
16453 }
16454 else
16455 {
16456 archive_file_offset = arch.next_arhdr_offset;
16457 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16458
2cf0635d
NC		 16459 ret |= process_object (qualified_name, file);
16460 }
fb52b2f4 16461
2b52916e
L		 16462 if (dump_sects != NULL)
16463 {
16464 free (dump_sects);
16465 dump_sects = NULL;
16466 num_dump_sects = 0;
16467 }
16468
2cf0635d 16469 free (qualified_name);
fb52b2f4
NC		 16470 }
16471
4145f1d5 16472 out:
2cf0635d
NC		 16473 if (nested_arch.file != NULL)
16474 fclose (nested_arch.file);
16475 release_archive (&nested_arch);
16476 release_archive (&arch);
fb52b2f4 16477
d989285c 16478 return ret;
fb52b2f4
NC		 16479}
16480
16481static int
2cf0635d 16482process_file (char * file_name)
fb52b2f4 16483{
2cf0635d 16484 FILE * file;
fb52b2f4
NC		 16485 struct stat statbuf;
16486 char armag[SARMAG];
16487 int ret;
16488
16489 if (stat (file_name, &statbuf) < 0)
16490 {
f24ddbdd
NC		 16491 if (errno == ENOENT)
16492 error (_("'%s': No such file\n"), file_name);
16493 else
16494 error (_("Could not locate '%s'. System error message: %s\n"),
16495 file_name, strerror (errno));
16496 return 1;
16497 }
16498
16499 if (! S_ISREG (statbuf.st_mode))
16500 {
16501 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16502 return 1;
16503 }
16504
16505 file = fopen (file_name, "rb");
16506 if (file == NULL)
16507 {
f24ddbdd 16508 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16509 return 1;
16510 }
16511
16512 if (fread (armag, SARMAG, 1, file) != 1)
16513 {
4145f1d5 16514 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16515 fclose (file);
16516 return 1;
16517 }
16518
f54498b4
NC		 16519 current_file_size = (bfd_size_type) statbuf.st_size;
16520
fb52b2f4 16521 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16522 ret = process_archive (file_name, file, FALSE);
16523 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16524 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16525 else
16526 {
4145f1d5
NC		 16527 if (do_archive_index)
16528 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16529 file_name);
16530
fb52b2f4
NC		 16531 rewind (file);
16532 archive_file_size = archive_file_offset = 0;
16533 ret = process_object (file_name, file);
16534 }
16535
16536 fclose (file);
16537
f54498b4 16538 current_file_size = 0;
fb52b2f4
NC		 16539 return ret;
16540}
16541
252b5132
RH		 16542#ifdef SUPPORT_DISASSEMBLY
16543/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16544 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16545 symbols. */
252b5132
RH		 16546
16547void
2cf0635d 16548print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16549{
16550 fprintf (outfile,"0x%8.8x", addr);
16551}
16552
e3c8793a 16553/* Needed by the i386 disassembler. */
252b5132
RH		 16554void
16555db_task_printsym (unsigned int addr)
16556{
16557 print_address (addr, stderr);
16558}
16559#endif
16560
16561int
2cf0635d 16562main (int argc, char ** argv)
252b5132 16563{
ff78d6d6
L		 16564 int err;
16565
252b5132
RH		 16566#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16567 setlocale (LC_MESSAGES, "");
3882b010
L		 16568#endif
16569#if defined (HAVE_SETLOCALE)
16570 setlocale (LC_CTYPE, "");
252b5132
RH		 16571#endif
16572 bindtextdomain (PACKAGE, LOCALEDIR);
16573 textdomain (PACKAGE);
16574
869b9d07
MM		 16575 expandargv (&argc, &argv);
16576
252b5132
RH		 16577 parse_args (argc, argv);
16578
18bd398b 16579 if (num_dump_sects > 0)
59f14fc0 16580 {
18bd398b 16581 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16582 cmdline_dump_sects = (dump_type *)
16583 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16584 if (cmdline_dump_sects == NULL)
591a748a 16585 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16586 else
16587 {
09c11c86
NC		 16588 memcpy (cmdline_dump_sects, dump_sects,
16589 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16590 num_cmdline_dump_sects = num_dump_sects;
16591 }
16592 }
16593
18bd398b
NC		 16594 if (optind < (argc - 1))
16595 show_name = 1;
5656ba2c
L		 16596 else if (optind >= argc)
16597 {
16598 warn (_("Nothing to do.\n"));
16599 usage (stderr);
16600 }
18bd398b 16601
ff78d6d6 16602 err = 0;
252b5132 16603 while (optind < argc)
18bd398b 16604 err |= process_file (argv[optind++]);
252b5132
RH		 16605
16606 if (dump_sects != NULL)
16607 free (dump_sects);
59f14fc0
AS		 16608 if (cmdline_dump_sects != NULL)
16609 free (cmdline_dump_sects);
252b5132 16610
ff78d6d6 16611 return err;
252b5132 16612}
A mirror of the official binutils-gdb repository