]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix memory leaks in chew program.
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
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
11 the Free Software Foundation; either version 3 of the License, or
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
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
23\f
24/* The difference between readelf and objdump:
25
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
28
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
43#include "sysdep.h"
44#include <assert.h>
45#include <time.h>
46#include <zlib.h>
47#ifdef HAVE_WCHAR_H
48#include <wchar.h>
49#endif
50
51#if __GNUC__ >= 2
52/* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
56#define BFD64
57#endif
58
59#include "bfd.h"
60#include "bucomm.h"
61#include "elfcomm.h"
62#include "dwarf.h"
63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
67
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
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
92#include "elf/aarch64.h"
93#include "elf/alpha.h"
94#include "elf/arc.h"
95#include "elf/arm.h"
96#include "elf/avr.h"
97#include "elf/bfin.h"
98#include "elf/cr16.h"
99#include "elf/cris.h"
100#include "elf/crx.h"
101#include "elf/d10v.h"
102#include "elf/d30v.h"
103#include "elf/dlx.h"
104#include "elf/epiphany.h"
105#include "elf/fr30.h"
106#include "elf/frv.h"
107#include "elf/ft32.h"
108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
111#include "elf/i370.h"
112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
115#include "elf/ip2k.h"
116#include "elf/lm32.h"
117#include "elf/iq2000.h"
118#include "elf/m32c.h"
119#include "elf/m32r.h"
120#include "elf/m68k.h"
121#include "elf/m68hc11.h"
122#include "elf/mcore.h"
123#include "elf/mep.h"
124#include "elf/metag.h"
125#include "elf/microblaze.h"
126#include "elf/mips.h"
127#include "elf/mmix.h"
128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
130#include "elf/moxie.h"
131#include "elf/mt.h"
132#include "elf/msp430.h"
133#include "elf/nds32.h"
134#include "elf/nios2.h"
135#include "elf/or1k.h"
136#include "elf/pj.h"
137#include "elf/ppc.h"
138#include "elf/ppc64.h"
139#include "elf/rl78.h"
140#include "elf/rx.h"
141#include "elf/s390.h"
142#include "elf/score.h"
143#include "elf/sh.h"
144#include "elf/sparc.h"
145#include "elf/spu.h"
146#include "elf/tic6x.h"
147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
149#include "elf/v850.h"
150#include "elf/vax.h"
151#include "elf/visium.h"
152#include "elf/x86-64.h"
153#include "elf/xc16x.h"
154#include "elf/xgate.h"
155#include "elf/xstormy16.h"
156#include "elf/xtensa.h"
157
158#include "getopt.h"
159#include "libiberty.h"
160#include "safe-ctype.h"
161#include "filenames.h"
162
163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
167typedef struct elf_section_list
168{
169 Elf_Internal_Shdr * hdr;
170 struct elf_section_list * next;
171} elf_section_list;
172
173char * program_name = "readelf";
174static unsigned long archive_file_offset;
175static unsigned long archive_file_size;
176static bfd_size_type current_file_size;
177static unsigned long dynamic_addr;
178static bfd_size_type dynamic_size;
179static size_t dynamic_nent;
180static char * dynamic_strings;
181static unsigned long dynamic_strings_length;
182static char * string_table;
183static unsigned long string_table_length;
184static unsigned long num_dynamic_syms;
185static Elf_Internal_Sym * dynamic_symbols;
186static Elf_Internal_Syminfo * dynamic_syminfo;
187static unsigned long dynamic_syminfo_offset;
188static unsigned int dynamic_syminfo_nent;
189static char program_interpreter[PATH_MAX];
190static bfd_vma dynamic_info[DT_ENCODING];
191static bfd_vma dynamic_info_DT_GNU_HASH;
192static bfd_vma version_info[16];
193static Elf_Internal_Ehdr elf_header;
194static Elf_Internal_Shdr * section_headers;
195static Elf_Internal_Phdr * program_headers;
196static Elf_Internal_Dyn * dynamic_section;
197static elf_section_list * symtab_shndx_list;
198static int show_name;
199static int do_dynamic;
200static int do_syms;
201static int do_dyn_syms;
202static int do_reloc;
203static int do_sections;
204static int do_section_groups;
205static int do_section_details;
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;
212static int do_histogram;
213static int do_debugging;
214static int do_arch;
215static int do_notes;
216static int do_archive_index;
217static int is_32bit_elf;
218static int decompress_dumps;
219
220struct group_list
221{
222 struct group_list * next;
223 unsigned int section_index;
224};
225
226struct group
227{
228 struct group_list * root;
229 unsigned int group_index;
230};
231
232static size_t group_count;
233static struct group * section_groups;
234static struct group ** section_headers_groups;
235
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. */
242#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
243
244typedef unsigned char dump_type;
245
246/* A linked list of the section names for which dumps were requested. */
247struct dump_list_entry
248{
249 char * name;
250 dump_type type;
251 struct dump_list_entry * next;
252};
253static struct dump_list_entry * dump_sects_byname;
254
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;
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
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. */
265static dump_type * dump_sects = NULL;
266static unsigned int num_dump_sects = 0;
267
268
269/* How to print a vma value. */
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
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
296#define UNKNOWN -1
297
298#define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
303
304#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
305
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))
309
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)
314
315#define REMOVE_ARCH_BITS(ADDR) \
316 do \
317 { \
318 if (elf_header.e_machine == EM_ARM) \
319 (ADDR) &= ~1; \
320 } \
321 while (0)
322\f
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.
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
328 and REASON is not NULL then emit an error message using REASON as part of the
329 context. */
330
331static void *
332get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
334{
335 void * mvar;
336 bfd_size_type amt = size * nmemb;
337
338 if (size == 0 || nmemb == 0)
339 return NULL;
340
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%" BFD_VMA_FMT "x"
350 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
351 nmemb, size, reason);
352 return NULL;
353 }
354
355 /* Check for size overflow. */
356 if (amt < nmemb)
357 {
358 if (reason)
359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
360 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
361 nmemb, size, reason);
362 return NULL;
363 }
364
365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt > current_file_size
368 || offset + archive_file_offset + amt > current_file_size)
369 {
370 if (reason)
371 error (_("Reading 0x%" BFD_VMA_FMT "x"
372 " bytes extends past end of file for %s\n"),
373 amt, reason);
374 return NULL;
375 }
376
377 if (fseek (file, archive_file_offset + offset, SEEK_SET))
378 {
379 if (reason)
380 error (_("Unable to seek to 0x%lx for %s\n"),
381 archive_file_offset + offset, reason);
382 return NULL;
383 }
384
385 mvar = var;
386 if (mvar == NULL)
387 {
388 /* Check for overflow. */
389 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
390 /* + 1 so that we can '\0' terminate invalid string table sections. */
391 mvar = malloc ((size_t) amt + 1);
392
393 if (mvar == NULL)
394 {
395 if (reason)
396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
397 " bytes for %s\n"),
398 amt, reason);
399 return NULL;
400 }
401
402 ((char *) mvar)[amt] = '\0';
403 }
404
405 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
406 {
407 if (reason)
408 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
409 amt, reason);
410 if (mvar != var)
411 free (mvar);
412 return NULL;
413 }
414
415 return mvar;
416}
417
418/* Print a VMA value. */
419
420static int
421print_vma (bfd_vma vma, print_mode mode)
422{
423 int nc = 0;
424
425 switch (mode)
426 {
427 case FULL_HEX:
428 nc = printf ("0x");
429 /* Drop through. */
430
431 case LONG_HEX:
432#ifdef BFD64
433 if (is_32bit_elf)
434 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
435#endif
436 printf_vma (vma);
437 return nc + 16;
438
439 case DEC_5:
440 if (vma <= 99999)
441 return printf ("%5" BFD_VMA_FMT "d", vma);
442 /* Drop through. */
443
444 case PREFIX_HEX:
445 nc = printf ("0x");
446 /* Drop through. */
447
448 case HEX:
449 return nc + printf ("%" BFD_VMA_FMT "x", vma);
450
451 case DEC:
452 return printf ("%" BFD_VMA_FMT "d", vma);
453
454 case UNSIGNED:
455 return printf ("%" BFD_VMA_FMT "u", vma);
456 }
457 return 0;
458}
459
460/* Display a symbol on stdout. Handles the display of control characters and
461 multibye characters (assuming the host environment supports them).
462
463 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
464
465 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
466 padding as necessary.
467
468 Returns the number of emitted characters. */
469
470static unsigned int
471print_symbol (int width, const char *symbol)
472{
473 bfd_boolean extra_padding = FALSE;
474 int num_printed = 0;
475#ifdef HAVE_MBSTATE_T
476 mbstate_t state;
477#endif
478 int width_remaining;
479
480 if (width < 0)
481 {
482 /* Keep the width positive. This also helps. */
483 width = - width;
484 extra_padding = TRUE;
485 }
486 assert (width != 0);
487
488 if (do_wide)
489 /* Set the remaining width to a very large value.
490 This simplifies the code below. */
491 width_remaining = INT_MAX;
492 else
493 width_remaining = width;
494
495#ifdef HAVE_MBSTATE_T
496 /* Initialise the multibyte conversion state. */
497 memset (& state, 0, sizeof (state));
498#endif
499
500 while (width_remaining)
501 {
502 size_t n;
503 const char c = *symbol++;
504
505 if (c == 0)
506 break;
507
508 /* Do not print control characters directly as they can affect terminal
509 settings. Such characters usually appear in the names generated
510 by the assembler for local labels. */
511 if (ISCNTRL (c))
512 {
513 if (width_remaining < 2)
514 break;
515
516 printf ("^%c", c + 0x40);
517 width_remaining -= 2;
518 num_printed += 2;
519 }
520 else if (ISPRINT (c))
521 {
522 putchar (c);
523 width_remaining --;
524 num_printed ++;
525 }
526 else
527 {
528#ifdef HAVE_MBSTATE_T
529 wchar_t w;
530#endif
531 /* Let printf do the hard work of displaying multibyte characters. */
532 printf ("%.1s", symbol - 1);
533 width_remaining --;
534 num_printed ++;
535
536#ifdef HAVE_MBSTATE_T
537 /* Try to find out how many bytes made up the character that was
538 just printed. Advance the symbol pointer past the bytes that
539 were displayed. */
540 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
541#else
542 n = 1;
543#endif
544 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
545 symbol += (n - 1);
546 }
547 }
548
549 if (extra_padding && num_printed < width)
550 {
551 /* Fill in the remaining spaces. */
552 printf ("%-*s", width - num_printed, " ");
553 num_printed = width;
554 }
555
556 return num_printed;
557}
558
559/* Returns a pointer to a static buffer containing a printable version of
560 the given section's name. Like print_symbol, except that it does not try
561 to print multibyte characters, it just interprets them as hex values. */
562
563static const char *
564printable_section_name (const Elf_Internal_Shdr * sec)
565{
566#define MAX_PRINT_SEC_NAME_LEN 128
567 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
568 const char * name = SECTION_NAME (sec);
569 char * buf = sec_name_buf;
570 char c;
571 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
572
573 while ((c = * name ++) != 0)
574 {
575 if (ISCNTRL (c))
576 {
577 if (remaining < 2)
578 break;
579
580 * buf ++ = '^';
581 * buf ++ = c + 0x40;
582 remaining -= 2;
583 }
584 else if (ISPRINT (c))
585 {
586 * buf ++ = c;
587 remaining -= 1;
588 }
589 else
590 {
591 static char hex[17] = "0123456789ABCDEF";
592
593 if (remaining < 4)
594 break;
595 * buf ++ = '<';
596 * buf ++ = hex[(c & 0xf0) >> 4];
597 * buf ++ = hex[c & 0x0f];
598 * buf ++ = '>';
599 remaining -= 4;
600 }
601
602 if (remaining == 0)
603 break;
604 }
605
606 * buf = 0;
607 return sec_name_buf;
608}
609
610static const char *
611printable_section_name_from_index (unsigned long ndx)
612{
613 if (ndx >= elf_header.e_shnum)
614 return _("<corrupt>");
615
616 return printable_section_name (section_headers + ndx);
617}
618
619/* Return a pointer to section NAME, or NULL if no such section exists. */
620
621static Elf_Internal_Shdr *
622find_section (const char * name)
623{
624 unsigned int i;
625
626 for (i = 0; i < elf_header.e_shnum; i++)
627 if (streq (SECTION_NAME (section_headers + i), name))
628 return section_headers + i;
629
630 return NULL;
631}
632
633/* Return a pointer to a section containing ADDR, or NULL if no such
634 section exists. */
635
636static Elf_Internal_Shdr *
637find_section_by_address (bfd_vma addr)
638{
639 unsigned int i;
640
641 for (i = 0; i < elf_header.e_shnum; i++)
642 {
643 Elf_Internal_Shdr *sec = section_headers + i;
644 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
645 return sec;
646 }
647
648 return NULL;
649}
650
651static Elf_Internal_Shdr *
652find_section_by_type (unsigned int type)
653{
654 unsigned int i;
655
656 for (i = 0; i < elf_header.e_shnum; i++)
657 {
658 Elf_Internal_Shdr *sec = section_headers + i;
659 if (sec->sh_type == type)
660 return sec;
661 }
662
663 return NULL;
664}
665
666/* Return a pointer to section NAME, or NULL if no such section exists,
667 restricted to the list of sections given in SET. */
668
669static Elf_Internal_Shdr *
670find_section_in_set (const char * name, unsigned int * set)
671{
672 unsigned int i;
673
674 if (set != NULL)
675 {
676 while ((i = *set++) > 0)
677 if (streq (SECTION_NAME (section_headers + i), name))
678 return section_headers + i;
679 }
680
681 return find_section (name);
682}
683
684/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
685 bytes read. */
686
687static inline unsigned long
688read_uleb128 (unsigned char *data,
689 unsigned int *length_return,
690 const unsigned char * const end)
691{
692 return read_leb128 (data, length_return, FALSE, end);
693}
694
695/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
696 This OS has so many departures from the ELF standard that we test it at
697 many places. */
698
699static inline int
700is_ia64_vms (void)
701{
702 return elf_header.e_machine == EM_IA_64
703 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
704}
705
706/* Guess the relocation size commonly used by the specific machines. */
707
708static int
709guess_is_rela (unsigned int e_machine)
710{
711 switch (e_machine)
712 {
713 /* Targets that use REL relocations. */
714 case EM_386:
715 case EM_IAMCU:
716 case EM_960:
717 case EM_ARM:
718 case EM_D10V:
719 case EM_CYGNUS_D10V:
720 case EM_DLX:
721 case EM_MIPS:
722 case EM_MIPS_RS3_LE:
723 case EM_CYGNUS_M32R:
724 case EM_SCORE:
725 case EM_XGATE:
726 return FALSE;
727
728 /* Targets that use RELA relocations. */
729 case EM_68K:
730 case EM_860:
731 case EM_AARCH64:
732 case EM_ADAPTEVA_EPIPHANY:
733 case EM_ALPHA:
734 case EM_ALTERA_NIOS2:
735 case EM_ARC:
736 case EM_ARC_COMPACT:
737 case EM_ARC_COMPACT2:
738 case EM_AVR:
739 case EM_AVR_OLD:
740 case EM_BLACKFIN:
741 case EM_CR16:
742 case EM_CRIS:
743 case EM_CRX:
744 case EM_D30V:
745 case EM_CYGNUS_D30V:
746 case EM_FR30:
747 case EM_FT32:
748 case EM_CYGNUS_FR30:
749 case EM_CYGNUS_FRV:
750 case EM_H8S:
751 case EM_H8_300:
752 case EM_H8_300H:
753 case EM_IA_64:
754 case EM_IP2K:
755 case EM_IP2K_OLD:
756 case EM_IQ2000:
757 case EM_LATTICEMICO32:
758 case EM_M32C_OLD:
759 case EM_M32C:
760 case EM_M32R:
761 case EM_MCORE:
762 case EM_CYGNUS_MEP:
763 case EM_METAG:
764 case EM_MMIX:
765 case EM_MN10200:
766 case EM_CYGNUS_MN10200:
767 case EM_MN10300:
768 case EM_CYGNUS_MN10300:
769 case EM_MOXIE:
770 case EM_MSP430:
771 case EM_MSP430_OLD:
772 case EM_MT:
773 case EM_NDS32:
774 case EM_NIOS32:
775 case EM_OR1K:
776 case EM_PPC64:
777 case EM_PPC:
778 case EM_RL78:
779 case EM_RX:
780 case EM_S390:
781 case EM_S390_OLD:
782 case EM_SH:
783 case EM_SPARC:
784 case EM_SPARC32PLUS:
785 case EM_SPARCV9:
786 case EM_SPU:
787 case EM_TI_C6000:
788 case EM_TILEGX:
789 case EM_TILEPRO:
790 case EM_V800:
791 case EM_V850:
792 case EM_CYGNUS_V850:
793 case EM_VAX:
794 case EM_VISIUM:
795 case EM_X86_64:
796 case EM_L1OM:
797 case EM_K1OM:
798 case EM_XSTORMY16:
799 case EM_XTENSA:
800 case EM_XTENSA_OLD:
801 case EM_MICROBLAZE:
802 case EM_MICROBLAZE_OLD:
803 return TRUE;
804
805 case EM_68HC05:
806 case EM_68HC08:
807 case EM_68HC11:
808 case EM_68HC16:
809 case EM_FX66:
810 case EM_ME16:
811 case EM_MMA:
812 case EM_NCPU:
813 case EM_NDR1:
814 case EM_PCP:
815 case EM_ST100:
816 case EM_ST19:
817 case EM_ST7:
818 case EM_ST9PLUS:
819 case EM_STARCORE:
820 case EM_SVX:
821 case EM_TINYJ:
822 default:
823 warn (_("Don't know about relocations on this machine architecture\n"));
824 return FALSE;
825 }
826}
827
828static int
829slurp_rela_relocs (FILE * file,
830 unsigned long rel_offset,
831 unsigned long rel_size,
832 Elf_Internal_Rela ** relasp,
833 unsigned long * nrelasp)
834{
835 Elf_Internal_Rela * relas;
836 size_t nrelas;
837 unsigned int i;
838
839 if (is_32bit_elf)
840 {
841 Elf32_External_Rela * erelas;
842
843 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
844 rel_size, _("32-bit relocation data"));
845 if (!erelas)
846 return 0;
847
848 nrelas = rel_size / sizeof (Elf32_External_Rela);
849
850 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
851 sizeof (Elf_Internal_Rela));
852
853 if (relas == NULL)
854 {
855 free (erelas);
856 error (_("out of memory parsing relocs\n"));
857 return 0;
858 }
859
860 for (i = 0; i < nrelas; i++)
861 {
862 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
863 relas[i].r_info = BYTE_GET (erelas[i].r_info);
864 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
865 }
866
867 free (erelas);
868 }
869 else
870 {
871 Elf64_External_Rela * erelas;
872
873 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
874 rel_size, _("64-bit relocation data"));
875 if (!erelas)
876 return 0;
877
878 nrelas = rel_size / sizeof (Elf64_External_Rela);
879
880 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
881 sizeof (Elf_Internal_Rela));
882
883 if (relas == NULL)
884 {
885 free (erelas);
886 error (_("out of memory parsing relocs\n"));
887 return 0;
888 }
889
890 for (i = 0; i < nrelas; i++)
891 {
892 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
893 relas[i].r_info = BYTE_GET (erelas[i].r_info);
894 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
895
896 /* The #ifdef BFD64 below is to prevent a compile time
897 warning. We know that if we do not have a 64 bit data
898 type that we will never execute this code anyway. */
899#ifdef BFD64
900 if (elf_header.e_machine == EM_MIPS
901 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
902 {
903 /* In little-endian objects, r_info isn't really a
904 64-bit little-endian value: it has a 32-bit
905 little-endian symbol index followed by four
906 individual byte fields. Reorder INFO
907 accordingly. */
908 bfd_vma inf = relas[i].r_info;
909 inf = (((inf & 0xffffffff) << 32)
910 | ((inf >> 56) & 0xff)
911 | ((inf >> 40) & 0xff00)
912 | ((inf >> 24) & 0xff0000)
913 | ((inf >> 8) & 0xff000000));
914 relas[i].r_info = inf;
915 }
916#endif /* BFD64 */
917 }
918
919 free (erelas);
920 }
921 *relasp = relas;
922 *nrelasp = nrelas;
923 return 1;
924}
925
926static int
927slurp_rel_relocs (FILE * file,
928 unsigned long rel_offset,
929 unsigned long rel_size,
930 Elf_Internal_Rela ** relsp,
931 unsigned long * nrelsp)
932{
933 Elf_Internal_Rela * rels;
934 size_t nrels;
935 unsigned int i;
936
937 if (is_32bit_elf)
938 {
939 Elf32_External_Rel * erels;
940
941 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
942 rel_size, _("32-bit relocation data"));
943 if (!erels)
944 return 0;
945
946 nrels = rel_size / sizeof (Elf32_External_Rel);
947
948 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
949
950 if (rels == NULL)
951 {
952 free (erels);
953 error (_("out of memory parsing relocs\n"));
954 return 0;
955 }
956
957 for (i = 0; i < nrels; i++)
958 {
959 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
960 rels[i].r_info = BYTE_GET (erels[i].r_info);
961 rels[i].r_addend = 0;
962 }
963
964 free (erels);
965 }
966 else
967 {
968 Elf64_External_Rel * erels;
969
970 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
971 rel_size, _("64-bit relocation data"));
972 if (!erels)
973 return 0;
974
975 nrels = rel_size / sizeof (Elf64_External_Rel);
976
977 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
978
979 if (rels == NULL)
980 {
981 free (erels);
982 error (_("out of memory parsing relocs\n"));
983 return 0;
984 }
985
986 for (i = 0; i < nrels; i++)
987 {
988 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
989 rels[i].r_info = BYTE_GET (erels[i].r_info);
990 rels[i].r_addend = 0;
991
992 /* The #ifdef BFD64 below is to prevent a compile time
993 warning. We know that if we do not have a 64 bit data
994 type that we will never execute this code anyway. */
995#ifdef BFD64
996 if (elf_header.e_machine == EM_MIPS
997 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
998 {
999 /* In little-endian objects, r_info isn't really a
1000 64-bit little-endian value: it has a 32-bit
1001 little-endian symbol index followed by four
1002 individual byte fields. Reorder INFO
1003 accordingly. */
1004 bfd_vma inf = rels[i].r_info;
1005 inf = (((inf & 0xffffffff) << 32)
1006 | ((inf >> 56) & 0xff)
1007 | ((inf >> 40) & 0xff00)
1008 | ((inf >> 24) & 0xff0000)
1009 | ((inf >> 8) & 0xff000000));
1010 rels[i].r_info = inf;
1011 }
1012#endif /* BFD64 */
1013 }
1014
1015 free (erels);
1016 }
1017 *relsp = rels;
1018 *nrelsp = nrels;
1019 return 1;
1020}
1021
1022/* Returns the reloc type extracted from the reloc info field. */
1023
1024static unsigned int
1025get_reloc_type (bfd_vma reloc_info)
1026{
1027 if (is_32bit_elf)
1028 return ELF32_R_TYPE (reloc_info);
1029
1030 switch (elf_header.e_machine)
1031 {
1032 case EM_MIPS:
1033 /* Note: We assume that reloc_info has already been adjusted for us. */
1034 return ELF64_MIPS_R_TYPE (reloc_info);
1035
1036 case EM_SPARCV9:
1037 return ELF64_R_TYPE_ID (reloc_info);
1038
1039 default:
1040 return ELF64_R_TYPE (reloc_info);
1041 }
1042}
1043
1044/* Return the symbol index extracted from the reloc info field. */
1045
1046static bfd_vma
1047get_reloc_symindex (bfd_vma reloc_info)
1048{
1049 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1050}
1051
1052static inline bfd_boolean
1053uses_msp430x_relocs (void)
1054{
1055 return
1056 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1057 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1058 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1059 /* TI compiler uses ELFOSABI_NONE. */
1060 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1061}
1062
1063/* Display the contents of the relocation data found at the specified
1064 offset. */
1065
1066static void
1067dump_relocations (FILE * file,
1068 unsigned long rel_offset,
1069 unsigned long rel_size,
1070 Elf_Internal_Sym * symtab,
1071 unsigned long nsyms,
1072 char * strtab,
1073 unsigned long strtablen,
1074 int is_rela,
1075 int is_dynsym)
1076{
1077 unsigned int i;
1078 Elf_Internal_Rela * rels;
1079
1080 if (is_rela == UNKNOWN)
1081 is_rela = guess_is_rela (elf_header.e_machine);
1082
1083 if (is_rela)
1084 {
1085 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1086 return;
1087 }
1088 else
1089 {
1090 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1091 return;
1092 }
1093
1094 if (is_32bit_elf)
1095 {
1096 if (is_rela)
1097 {
1098 if (do_wide)
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1100 else
1101 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1102 }
1103 else
1104 {
1105 if (do_wide)
1106 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1107 else
1108 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1109 }
1110 }
1111 else
1112 {
1113 if (is_rela)
1114 {
1115 if (do_wide)
1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1117 else
1118 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1119 }
1120 else
1121 {
1122 if (do_wide)
1123 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1124 else
1125 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1126 }
1127 }
1128
1129 for (i = 0; i < rel_size; i++)
1130 {
1131 const char * rtype;
1132 bfd_vma offset;
1133 bfd_vma inf;
1134 bfd_vma symtab_index;
1135 bfd_vma type;
1136
1137 offset = rels[i].r_offset;
1138 inf = rels[i].r_info;
1139
1140 type = get_reloc_type (inf);
1141 symtab_index = get_reloc_symindex (inf);
1142
1143 if (is_32bit_elf)
1144 {
1145 printf ("%8.8lx %8.8lx ",
1146 (unsigned long) offset & 0xffffffff,
1147 (unsigned long) inf & 0xffffffff);
1148 }
1149 else
1150 {
1151#if BFD_HOST_64BIT_LONG
1152 printf (do_wide
1153 ? "%16.16lx %16.16lx "
1154 : "%12.12lx %12.12lx ",
1155 offset, inf);
1156#elif BFD_HOST_64BIT_LONG_LONG
1157#ifndef __MSVCRT__
1158 printf (do_wide
1159 ? "%16.16llx %16.16llx "
1160 : "%12.12llx %12.12llx ",
1161 offset, inf);
1162#else
1163 printf (do_wide
1164 ? "%16.16I64x %16.16I64x "
1165 : "%12.12I64x %12.12I64x ",
1166 offset, inf);
1167#endif
1168#else
1169 printf (do_wide
1170 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1171 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1172 _bfd_int64_high (offset),
1173 _bfd_int64_low (offset),
1174 _bfd_int64_high (inf),
1175 _bfd_int64_low (inf));
1176#endif
1177 }
1178
1179 switch (elf_header.e_machine)
1180 {
1181 default:
1182 rtype = NULL;
1183 break;
1184
1185 case EM_AARCH64:
1186 rtype = elf_aarch64_reloc_type (type);
1187 break;
1188
1189 case EM_M32R:
1190 case EM_CYGNUS_M32R:
1191 rtype = elf_m32r_reloc_type (type);
1192 break;
1193
1194 case EM_386:
1195 case EM_IAMCU:
1196 rtype = elf_i386_reloc_type (type);
1197 break;
1198
1199 case EM_68HC11:
1200 case EM_68HC12:
1201 rtype = elf_m68hc11_reloc_type (type);
1202 break;
1203
1204 case EM_68K:
1205 rtype = elf_m68k_reloc_type (type);
1206 break;
1207
1208 case EM_960:
1209 rtype = elf_i960_reloc_type (type);
1210 break;
1211
1212 case EM_AVR:
1213 case EM_AVR_OLD:
1214 rtype = elf_avr_reloc_type (type);
1215 break;
1216
1217 case EM_OLD_SPARCV9:
1218 case EM_SPARC32PLUS:
1219 case EM_SPARCV9:
1220 case EM_SPARC:
1221 rtype = elf_sparc_reloc_type (type);
1222 break;
1223
1224 case EM_SPU:
1225 rtype = elf_spu_reloc_type (type);
1226 break;
1227
1228 case EM_V800:
1229 rtype = v800_reloc_type (type);
1230 break;
1231 case EM_V850:
1232 case EM_CYGNUS_V850:
1233 rtype = v850_reloc_type (type);
1234 break;
1235
1236 case EM_D10V:
1237 case EM_CYGNUS_D10V:
1238 rtype = elf_d10v_reloc_type (type);
1239 break;
1240
1241 case EM_D30V:
1242 case EM_CYGNUS_D30V:
1243 rtype = elf_d30v_reloc_type (type);
1244 break;
1245
1246 case EM_DLX:
1247 rtype = elf_dlx_reloc_type (type);
1248 break;
1249
1250 case EM_SH:
1251 rtype = elf_sh_reloc_type (type);
1252 break;
1253
1254 case EM_MN10300:
1255 case EM_CYGNUS_MN10300:
1256 rtype = elf_mn10300_reloc_type (type);
1257 break;
1258
1259 case EM_MN10200:
1260 case EM_CYGNUS_MN10200:
1261 rtype = elf_mn10200_reloc_type (type);
1262 break;
1263
1264 case EM_FR30:
1265 case EM_CYGNUS_FR30:
1266 rtype = elf_fr30_reloc_type (type);
1267 break;
1268
1269 case EM_CYGNUS_FRV:
1270 rtype = elf_frv_reloc_type (type);
1271 break;
1272
1273 case EM_FT32:
1274 rtype = elf_ft32_reloc_type (type);
1275 break;
1276
1277 case EM_MCORE:
1278 rtype = elf_mcore_reloc_type (type);
1279 break;
1280
1281 case EM_MMIX:
1282 rtype = elf_mmix_reloc_type (type);
1283 break;
1284
1285 case EM_MOXIE:
1286 rtype = elf_moxie_reloc_type (type);
1287 break;
1288
1289 case EM_MSP430:
1290 if (uses_msp430x_relocs ())
1291 {
1292 rtype = elf_msp430x_reloc_type (type);
1293 break;
1294 }
1295 case EM_MSP430_OLD:
1296 rtype = elf_msp430_reloc_type (type);
1297 break;
1298
1299 case EM_NDS32:
1300 rtype = elf_nds32_reloc_type (type);
1301 break;
1302
1303 case EM_PPC:
1304 rtype = elf_ppc_reloc_type (type);
1305 break;
1306
1307 case EM_PPC64:
1308 rtype = elf_ppc64_reloc_type (type);
1309 break;
1310
1311 case EM_MIPS:
1312 case EM_MIPS_RS3_LE:
1313 rtype = elf_mips_reloc_type (type);
1314 break;
1315
1316 case EM_ALPHA:
1317 rtype = elf_alpha_reloc_type (type);
1318 break;
1319
1320 case EM_ARM:
1321 rtype = elf_arm_reloc_type (type);
1322 break;
1323
1324 case EM_ARC:
1325 case EM_ARC_COMPACT:
1326 case EM_ARC_COMPACT2:
1327 rtype = elf_arc_reloc_type (type);
1328 break;
1329
1330 case EM_PARISC:
1331 rtype = elf_hppa_reloc_type (type);
1332 break;
1333
1334 case EM_H8_300:
1335 case EM_H8_300H:
1336 case EM_H8S:
1337 rtype = elf_h8_reloc_type (type);
1338 break;
1339
1340 case EM_OR1K:
1341 rtype = elf_or1k_reloc_type (type);
1342 break;
1343
1344 case EM_PJ:
1345 case EM_PJ_OLD:
1346 rtype = elf_pj_reloc_type (type);
1347 break;
1348 case EM_IA_64:
1349 rtype = elf_ia64_reloc_type (type);
1350 break;
1351
1352 case EM_CRIS:
1353 rtype = elf_cris_reloc_type (type);
1354 break;
1355
1356 case EM_860:
1357 rtype = elf_i860_reloc_type (type);
1358 break;
1359
1360 case EM_X86_64:
1361 case EM_L1OM:
1362 case EM_K1OM:
1363 rtype = elf_x86_64_reloc_type (type);
1364 break;
1365
1366 case EM_S370:
1367 rtype = i370_reloc_type (type);
1368 break;
1369
1370 case EM_S390_OLD:
1371 case EM_S390:
1372 rtype = elf_s390_reloc_type (type);
1373 break;
1374
1375 case EM_SCORE:
1376 rtype = elf_score_reloc_type (type);
1377 break;
1378
1379 case EM_XSTORMY16:
1380 rtype = elf_xstormy16_reloc_type (type);
1381 break;
1382
1383 case EM_CRX:
1384 rtype = elf_crx_reloc_type (type);
1385 break;
1386
1387 case EM_VAX:
1388 rtype = elf_vax_reloc_type (type);
1389 break;
1390
1391 case EM_VISIUM:
1392 rtype = elf_visium_reloc_type (type);
1393 break;
1394
1395 case EM_ADAPTEVA_EPIPHANY:
1396 rtype = elf_epiphany_reloc_type (type);
1397 break;
1398
1399 case EM_IP2K:
1400 case EM_IP2K_OLD:
1401 rtype = elf_ip2k_reloc_type (type);
1402 break;
1403
1404 case EM_IQ2000:
1405 rtype = elf_iq2000_reloc_type (type);
1406 break;
1407
1408 case EM_XTENSA_OLD:
1409 case EM_XTENSA:
1410 rtype = elf_xtensa_reloc_type (type);
1411 break;
1412
1413 case EM_LATTICEMICO32:
1414 rtype = elf_lm32_reloc_type (type);
1415 break;
1416
1417 case EM_M32C_OLD:
1418 case EM_M32C:
1419 rtype = elf_m32c_reloc_type (type);
1420 break;
1421
1422 case EM_MT:
1423 rtype = elf_mt_reloc_type (type);
1424 break;
1425
1426 case EM_BLACKFIN:
1427 rtype = elf_bfin_reloc_type (type);
1428 break;
1429
1430 case EM_CYGNUS_MEP:
1431 rtype = elf_mep_reloc_type (type);
1432 break;
1433
1434 case EM_CR16:
1435 rtype = elf_cr16_reloc_type (type);
1436 break;
1437
1438 case EM_MICROBLAZE:
1439 case EM_MICROBLAZE_OLD:
1440 rtype = elf_microblaze_reloc_type (type);
1441 break;
1442
1443 case EM_RL78:
1444 rtype = elf_rl78_reloc_type (type);
1445 break;
1446
1447 case EM_RX:
1448 rtype = elf_rx_reloc_type (type);
1449 break;
1450
1451 case EM_METAG:
1452 rtype = elf_metag_reloc_type (type);
1453 break;
1454
1455 case EM_XC16X:
1456 case EM_C166:
1457 rtype = elf_xc16x_reloc_type (type);
1458 break;
1459
1460 case EM_TI_C6000:
1461 rtype = elf_tic6x_reloc_type (type);
1462 break;
1463
1464 case EM_TILEGX:
1465 rtype = elf_tilegx_reloc_type (type);
1466 break;
1467
1468 case EM_TILEPRO:
1469 rtype = elf_tilepro_reloc_type (type);
1470 break;
1471
1472 case EM_XGATE:
1473 rtype = elf_xgate_reloc_type (type);
1474 break;
1475
1476 case EM_ALTERA_NIOS2:
1477 rtype = elf_nios2_reloc_type (type);
1478 break;
1479 }
1480
1481 if (rtype == NULL)
1482 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1483 else
1484 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1485
1486 if (elf_header.e_machine == EM_ALPHA
1487 && rtype != NULL
1488 && streq (rtype, "R_ALPHA_LITUSE")
1489 && is_rela)
1490 {
1491 switch (rels[i].r_addend)
1492 {
1493 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1494 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1495 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1496 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1497 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1498 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1499 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1500 default: rtype = NULL;
1501 }
1502 if (rtype)
1503 printf (" (%s)", rtype);
1504 else
1505 {
1506 putchar (' ');
1507 printf (_("<unknown addend: %lx>"),
1508 (unsigned long) rels[i].r_addend);
1509 }
1510 }
1511 else if (symtab_index)
1512 {
1513 if (symtab == NULL || symtab_index >= nsyms)
1514 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1515 else
1516 {
1517 Elf_Internal_Sym * psym;
1518 const char * version_string;
1519 enum versioned_symbol_info sym_info;
1520 unsigned short vna_other;
1521
1522 psym = symtab + symtab_index;
1523
1524 version_string
1525 = get_symbol_version_string (file, is_dynsym,
1526 strtab, strtablen,
1527 symtab_index,
1528 psym,
1529 &sym_info,
1530 &vna_other);
1531
1532 printf (" ");
1533
1534 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1535 {
1536 const char * name;
1537 unsigned int len;
1538 unsigned int width = is_32bit_elf ? 8 : 14;
1539
1540 /* Relocations against GNU_IFUNC symbols do not use the value
1541 of the symbol as the address to relocate against. Instead
1542 they invoke the function named by the symbol and use its
1543 result as the address for relocation.
1544
1545 To indicate this to the user, do not display the value of
1546 the symbol in the "Symbols's Value" field. Instead show
1547 its name followed by () as a hint that the symbol is
1548 invoked. */
1549
1550 if (strtab == NULL
1551 || psym->st_name == 0
1552 || psym->st_name >= strtablen)
1553 name = "??";
1554 else
1555 name = strtab + psym->st_name;
1556
1557 len = print_symbol (width, name);
1558 if (version_string)
1559 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1560 version_string);
1561 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1562 }
1563 else
1564 {
1565 print_vma (psym->st_value, LONG_HEX);
1566
1567 printf (is_32bit_elf ? " " : " ");
1568 }
1569
1570 if (psym->st_name == 0)
1571 {
1572 const char * sec_name = "<null>";
1573 char name_buf[40];
1574
1575 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1576 {
1577 if (psym->st_shndx < elf_header.e_shnum)
1578 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1579 else if (psym->st_shndx == SHN_ABS)
1580 sec_name = "ABS";
1581 else if (psym->st_shndx == SHN_COMMON)
1582 sec_name = "COMMON";
1583 else if ((elf_header.e_machine == EM_MIPS
1584 && psym->st_shndx == SHN_MIPS_SCOMMON)
1585 || (elf_header.e_machine == EM_TI_C6000
1586 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1587 sec_name = "SCOMMON";
1588 else if (elf_header.e_machine == EM_MIPS
1589 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1590 sec_name = "SUNDEF";
1591 else if ((elf_header.e_machine == EM_X86_64
1592 || elf_header.e_machine == EM_L1OM
1593 || elf_header.e_machine == EM_K1OM)
1594 && psym->st_shndx == SHN_X86_64_LCOMMON)
1595 sec_name = "LARGE_COMMON";
1596 else if (elf_header.e_machine == EM_IA_64
1597 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1598 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1599 sec_name = "ANSI_COM";
1600 else if (is_ia64_vms ()
1601 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1602 sec_name = "VMS_SYMVEC";
1603 else
1604 {
1605 sprintf (name_buf, "<section 0x%x>",
1606 (unsigned int) psym->st_shndx);
1607 sec_name = name_buf;
1608 }
1609 }
1610 print_symbol (22, sec_name);
1611 }
1612 else if (strtab == NULL)
1613 printf (_("<string table index: %3ld>"), psym->st_name);
1614 else if (psym->st_name >= strtablen)
1615 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1616 else
1617 {
1618 print_symbol (22, strtab + psym->st_name);
1619 if (version_string)
1620 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1621 version_string);
1622 }
1623
1624 if (is_rela)
1625 {
1626 bfd_vma off = rels[i].r_addend;
1627
1628 if ((bfd_signed_vma) off < 0)
1629 printf (" - %" BFD_VMA_FMT "x", - off);
1630 else
1631 printf (" + %" BFD_VMA_FMT "x", off);
1632 }
1633 }
1634 }
1635 else if (is_rela)
1636 {
1637 bfd_vma off = rels[i].r_addend;
1638
1639 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1640 if ((bfd_signed_vma) off < 0)
1641 printf ("-%" BFD_VMA_FMT "x", - off);
1642 else
1643 printf ("%" BFD_VMA_FMT "x", off);
1644 }
1645
1646 if (elf_header.e_machine == EM_SPARCV9
1647 && rtype != NULL
1648 && streq (rtype, "R_SPARC_OLO10"))
1649 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1650
1651 putchar ('\n');
1652
1653#ifdef BFD64
1654 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1655 {
1656 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1657 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1658 const char * rtype2 = elf_mips_reloc_type (type2);
1659 const char * rtype3 = elf_mips_reloc_type (type3);
1660
1661 printf (" Type2: ");
1662
1663 if (rtype2 == NULL)
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type2 & 0xffffffff);
1666 else
1667 printf ("%-17.17s", rtype2);
1668
1669 printf ("\n Type3: ");
1670
1671 if (rtype3 == NULL)
1672 printf (_("unrecognized: %-7lx"),
1673 (unsigned long) type3 & 0xffffffff);
1674 else
1675 printf ("%-17.17s", rtype3);
1676
1677 putchar ('\n');
1678 }
1679#endif /* BFD64 */
1680 }
1681
1682 free (rels);
1683}
1684
1685static const char *
1686get_mips_dynamic_type (unsigned long type)
1687{
1688 switch (type)
1689 {
1690 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1691 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1692 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1693 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1694 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1695 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1696 case DT_MIPS_MSYM: return "MIPS_MSYM";
1697 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1698 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1699 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1700 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1701 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1702 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1703 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1704 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1705 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1706 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1707 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1708 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1709 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1710 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1711 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1712 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1713 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1714 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1715 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1716 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1717 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1718 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1719 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1720 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1721 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1722 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1723 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1724 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1725 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1726 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1727 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1728 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1729 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1730 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1731 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1732 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1733 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1734 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1735 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1736 default:
1737 return NULL;
1738 }
1739}
1740
1741static const char *
1742get_sparc64_dynamic_type (unsigned long type)
1743{
1744 switch (type)
1745 {
1746 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1747 default:
1748 return NULL;
1749 }
1750}
1751
1752static const char *
1753get_ppc_dynamic_type (unsigned long type)
1754{
1755 switch (type)
1756 {
1757 case DT_PPC_GOT: return "PPC_GOT";
1758 case DT_PPC_OPT: return "PPC_OPT";
1759 default:
1760 return NULL;
1761 }
1762}
1763
1764static const char *
1765get_ppc64_dynamic_type (unsigned long type)
1766{
1767 switch (type)
1768 {
1769 case DT_PPC64_GLINK: return "PPC64_GLINK";
1770 case DT_PPC64_OPD: return "PPC64_OPD";
1771 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1772 case DT_PPC64_OPT: return "PPC64_OPT";
1773 default:
1774 return NULL;
1775 }
1776}
1777
1778static const char *
1779get_parisc_dynamic_type (unsigned long type)
1780{
1781 switch (type)
1782 {
1783 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1784 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1785 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1786 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1787 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1788 case DT_HP_PREINIT: return "HP_PREINIT";
1789 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1790 case DT_HP_NEEDED: return "HP_NEEDED";
1791 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1792 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1793 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1794 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1795 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1796 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1797 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1798 case DT_HP_FILTERED: return "HP_FILTERED";
1799 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1800 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1801 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1802 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1803 case DT_PLT: return "PLT";
1804 case DT_PLT_SIZE: return "PLT_SIZE";
1805 case DT_DLT: return "DLT";
1806 case DT_DLT_SIZE: return "DLT_SIZE";
1807 default:
1808 return NULL;
1809 }
1810}
1811
1812static const char *
1813get_ia64_dynamic_type (unsigned long type)
1814{
1815 switch (type)
1816 {
1817 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1818 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1819 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1820 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1821 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1822 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1823 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1824 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1825 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1826 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1828 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1829 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1830 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1831 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1832 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1833 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1834 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1835 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1836 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1837 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1838 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1839 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1840 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1841 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1842 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1843 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1844 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1845 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1846 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1847 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1848 default:
1849 return NULL;
1850 }
1851}
1852
1853static const char *
1854get_solaris_section_type (unsigned long type)
1855{
1856 switch (type)
1857 {
1858 case 0x6fffffee: return "SUNW_ancillary";
1859 case 0x6fffffef: return "SUNW_capchain";
1860 case 0x6ffffff0: return "SUNW_capinfo";
1861 case 0x6ffffff1: return "SUNW_symsort";
1862 case 0x6ffffff2: return "SUNW_tlssort";
1863 case 0x6ffffff3: return "SUNW_LDYNSYM";
1864 case 0x6ffffff4: return "SUNW_dof";
1865 case 0x6ffffff5: return "SUNW_cap";
1866 case 0x6ffffff6: return "SUNW_SIGNATURE";
1867 case 0x6ffffff7: return "SUNW_ANNOTATE";
1868 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1869 case 0x6ffffff9: return "SUNW_DEBUG";
1870 case 0x6ffffffa: return "SUNW_move";
1871 case 0x6ffffffb: return "SUNW_COMDAT";
1872 case 0x6ffffffc: return "SUNW_syminfo";
1873 case 0x6ffffffd: return "SUNW_verdef";
1874 case 0x6ffffffe: return "SUNW_verneed";
1875 case 0x6fffffff: return "SUNW_versym";
1876 case 0x70000000: return "SPARC_GOTDATA";
1877 default: return NULL;
1878 }
1879}
1880
1881static const char *
1882get_alpha_dynamic_type (unsigned long type)
1883{
1884 switch (type)
1885 {
1886 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1887 default:
1888 return NULL;
1889 }
1890}
1891
1892static const char *
1893get_score_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1898 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1899 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1900 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1901 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1902 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1903 default:
1904 return NULL;
1905 }
1906}
1907
1908static const char *
1909get_tic6x_dynamic_type (unsigned long type)
1910{
1911 switch (type)
1912 {
1913 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1914 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1915 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1916 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1917 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1918 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1919 default:
1920 return NULL;
1921 }
1922}
1923
1924static const char *
1925get_nios2_dynamic_type (unsigned long type)
1926{
1927 switch (type)
1928 {
1929 case DT_NIOS2_GP: return "NIOS2_GP";
1930 default:
1931 return NULL;
1932 }
1933}
1934
1935static const char *
1936get_solaris_dynamic_type (unsigned long type)
1937{
1938 switch (type)
1939 {
1940 case 0x6000000d: return "SUNW_AUXILIARY";
1941 case 0x6000000e: return "SUNW_RTLDINF";
1942 case 0x6000000f: return "SUNW_FILTER";
1943 case 0x60000010: return "SUNW_CAP";
1944 case 0x60000011: return "SUNW_SYMTAB";
1945 case 0x60000012: return "SUNW_SYMSZ";
1946 case 0x60000013: return "SUNW_SORTENT";
1947 case 0x60000014: return "SUNW_SYMSORT";
1948 case 0x60000015: return "SUNW_SYMSORTSZ";
1949 case 0x60000016: return "SUNW_TLSSORT";
1950 case 0x60000017: return "SUNW_TLSSORTSZ";
1951 case 0x60000018: return "SUNW_CAPINFO";
1952 case 0x60000019: return "SUNW_STRPAD";
1953 case 0x6000001a: return "SUNW_CAPCHAIN";
1954 case 0x6000001b: return "SUNW_LDMACH";
1955 case 0x6000001d: return "SUNW_CAPCHAINENT";
1956 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1957 case 0x60000021: return "SUNW_PARENT";
1958 case 0x60000023: return "SUNW_ASLR";
1959 case 0x60000025: return "SUNW_RELAX";
1960 case 0x60000029: return "SUNW_NXHEAP";
1961 case 0x6000002b: return "SUNW_NXSTACK";
1962
1963 case 0x70000001: return "SPARC_REGISTER";
1964 case 0x7ffffffd: return "AUXILIARY";
1965 case 0x7ffffffe: return "USED";
1966 case 0x7fffffff: return "FILTER";
1967
1968 default: return NULL;
1969 }
1970}
1971
1972static const char *
1973get_dynamic_type (unsigned long type)
1974{
1975 static char buff[64];
1976
1977 switch (type)
1978 {
1979 case DT_NULL: return "NULL";
1980 case DT_NEEDED: return "NEEDED";
1981 case DT_PLTRELSZ: return "PLTRELSZ";
1982 case DT_PLTGOT: return "PLTGOT";
1983 case DT_HASH: return "HASH";
1984 case DT_STRTAB: return "STRTAB";
1985 case DT_SYMTAB: return "SYMTAB";
1986 case DT_RELA: return "RELA";
1987 case DT_RELASZ: return "RELASZ";
1988 case DT_RELAENT: return "RELAENT";
1989 case DT_STRSZ: return "STRSZ";
1990 case DT_SYMENT: return "SYMENT";
1991 case DT_INIT: return "INIT";
1992 case DT_FINI: return "FINI";
1993 case DT_SONAME: return "SONAME";
1994 case DT_RPATH: return "RPATH";
1995 case DT_SYMBOLIC: return "SYMBOLIC";
1996 case DT_REL: return "REL";
1997 case DT_RELSZ: return "RELSZ";
1998 case DT_RELENT: return "RELENT";
1999 case DT_PLTREL: return "PLTREL";
2000 case DT_DEBUG: return "DEBUG";
2001 case DT_TEXTREL: return "TEXTREL";
2002 case DT_JMPREL: return "JMPREL";
2003 case DT_BIND_NOW: return "BIND_NOW";
2004 case DT_INIT_ARRAY: return "INIT_ARRAY";
2005 case DT_FINI_ARRAY: return "FINI_ARRAY";
2006 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2007 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2008 case DT_RUNPATH: return "RUNPATH";
2009 case DT_FLAGS: return "FLAGS";
2010
2011 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2012 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2013
2014 case DT_CHECKSUM: return "CHECKSUM";
2015 case DT_PLTPADSZ: return "PLTPADSZ";
2016 case DT_MOVEENT: return "MOVEENT";
2017 case DT_MOVESZ: return "MOVESZ";
2018 case DT_FEATURE: return "FEATURE";
2019 case DT_POSFLAG_1: return "POSFLAG_1";
2020 case DT_SYMINSZ: return "SYMINSZ";
2021 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2022
2023 case DT_ADDRRNGLO: return "ADDRRNGLO";
2024 case DT_CONFIG: return "CONFIG";
2025 case DT_DEPAUDIT: return "DEPAUDIT";
2026 case DT_AUDIT: return "AUDIT";
2027 case DT_PLTPAD: return "PLTPAD";
2028 case DT_MOVETAB: return "MOVETAB";
2029 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2030
2031 case DT_VERSYM: return "VERSYM";
2032
2033 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2034 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2035 case DT_RELACOUNT: return "RELACOUNT";
2036 case DT_RELCOUNT: return "RELCOUNT";
2037 case DT_FLAGS_1: return "FLAGS_1";
2038 case DT_VERDEF: return "VERDEF";
2039 case DT_VERDEFNUM: return "VERDEFNUM";
2040 case DT_VERNEED: return "VERNEED";
2041 case DT_VERNEEDNUM: return "VERNEEDNUM";
2042
2043 case DT_AUXILIARY: return "AUXILIARY";
2044 case DT_USED: return "USED";
2045 case DT_FILTER: return "FILTER";
2046
2047 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2048 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2049 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2050 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2051 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2052 case DT_GNU_HASH: return "GNU_HASH";
2053
2054 default:
2055 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2056 {
2057 const char * result;
2058
2059 switch (elf_header.e_machine)
2060 {
2061 case EM_MIPS:
2062 case EM_MIPS_RS3_LE:
2063 result = get_mips_dynamic_type (type);
2064 break;
2065 case EM_SPARCV9:
2066 result = get_sparc64_dynamic_type (type);
2067 break;
2068 case EM_PPC:
2069 result = get_ppc_dynamic_type (type);
2070 break;
2071 case EM_PPC64:
2072 result = get_ppc64_dynamic_type (type);
2073 break;
2074 case EM_IA_64:
2075 result = get_ia64_dynamic_type (type);
2076 break;
2077 case EM_ALPHA:
2078 result = get_alpha_dynamic_type (type);
2079 break;
2080 case EM_SCORE:
2081 result = get_score_dynamic_type (type);
2082 break;
2083 case EM_TI_C6000:
2084 result = get_tic6x_dynamic_type (type);
2085 break;
2086 case EM_ALTERA_NIOS2:
2087 result = get_nios2_dynamic_type (type);
2088 break;
2089 default:
2090 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2091 result = get_solaris_dynamic_type (type);
2092 else
2093 result = NULL;
2094 break;
2095 }
2096
2097 if (result != NULL)
2098 return result;
2099
2100 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2101 }
2102 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2103 || (elf_header.e_machine == EM_PARISC
2104 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2105 {
2106 const char * result;
2107
2108 switch (elf_header.e_machine)
2109 {
2110 case EM_PARISC:
2111 result = get_parisc_dynamic_type (type);
2112 break;
2113 case EM_IA_64:
2114 result = get_ia64_dynamic_type (type);
2115 break;
2116 default:
2117 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2118 result = get_solaris_dynamic_type (type);
2119 else
2120 result = NULL;
2121 break;
2122 }
2123
2124 if (result != NULL)
2125 return result;
2126
2127 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2128 type);
2129 }
2130 else
2131 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2132
2133 return buff;
2134 }
2135}
2136
2137static char *
2138get_file_type (unsigned e_type)
2139{
2140 static char buff[32];
2141
2142 switch (e_type)
2143 {
2144 case ET_NONE: return _("NONE (None)");
2145 case ET_REL: return _("REL (Relocatable file)");
2146 case ET_EXEC: return _("EXEC (Executable file)");
2147 case ET_DYN: return _("DYN (Shared object file)");
2148 case ET_CORE: return _("CORE (Core file)");
2149
2150 default:
2151 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2152 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2153 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2154 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2155 else
2156 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2157 return buff;
2158 }
2159}
2160
2161static char *
2162get_machine_name (unsigned e_machine)
2163{
2164 static char buff[64]; /* XXX */
2165
2166 switch (e_machine)
2167 {
2168 case EM_NONE: return _("None");
2169 case EM_AARCH64: return "AArch64";
2170 case EM_M32: return "WE32100";
2171 case EM_SPARC: return "Sparc";
2172 case EM_SPU: return "SPU";
2173 case EM_386: return "Intel 80386";
2174 case EM_68K: return "MC68000";
2175 case EM_88K: return "MC88000";
2176 case EM_IAMCU: return "Intel MCU";
2177 case EM_860: return "Intel 80860";
2178 case EM_MIPS: return "MIPS R3000";
2179 case EM_S370: return "IBM System/370";
2180 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2181 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2182 case EM_PARISC: return "HPPA";
2183 case EM_PPC_OLD: return "Power PC (old)";
2184 case EM_SPARC32PLUS: return "Sparc v8+" ;
2185 case EM_960: return "Intel 90860";
2186 case EM_PPC: return "PowerPC";
2187 case EM_PPC64: return "PowerPC64";
2188 case EM_FR20: return "Fujitsu FR20";
2189 case EM_FT32: return "FTDI FT32";
2190 case EM_RH32: return "TRW RH32";
2191 case EM_MCORE: return "MCORE";
2192 case EM_ARM: return "ARM";
2193 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2194 case EM_SH: return "Renesas / SuperH SH";
2195 case EM_SPARCV9: return "Sparc v9";
2196 case EM_TRICORE: return "Siemens Tricore";
2197 case EM_ARC: return "ARC";
2198 case EM_ARC_COMPACT: return "ARCompact";
2199 case EM_ARC_COMPACT2: return "ARCv2";
2200 case EM_H8_300: return "Renesas H8/300";
2201 case EM_H8_300H: return "Renesas H8/300H";
2202 case EM_H8S: return "Renesas H8S";
2203 case EM_H8_500: return "Renesas H8/500";
2204 case EM_IA_64: return "Intel IA-64";
2205 case EM_MIPS_X: return "Stanford MIPS-X";
2206 case EM_COLDFIRE: return "Motorola Coldfire";
2207 case EM_ALPHA: return "Alpha";
2208 case EM_CYGNUS_D10V:
2209 case EM_D10V: return "d10v";
2210 case EM_CYGNUS_D30V:
2211 case EM_D30V: return "d30v";
2212 case EM_CYGNUS_M32R:
2213 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2214 case EM_CYGNUS_V850:
2215 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2216 case EM_V850: return "Renesas V850";
2217 case EM_CYGNUS_MN10300:
2218 case EM_MN10300: return "mn10300";
2219 case EM_CYGNUS_MN10200:
2220 case EM_MN10200: return "mn10200";
2221 case EM_MOXIE: return "Moxie";
2222 case EM_CYGNUS_FR30:
2223 case EM_FR30: return "Fujitsu FR30";
2224 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2225 case EM_PJ_OLD:
2226 case EM_PJ: return "picoJava";
2227 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2228 case EM_PCP: return "Siemens PCP";
2229 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2230 case EM_NDR1: return "Denso NDR1 microprocesspr";
2231 case EM_STARCORE: return "Motorola Star*Core processor";
2232 case EM_ME16: return "Toyota ME16 processor";
2233 case EM_ST100: return "STMicroelectronics ST100 processor";
2234 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2235 case EM_PDSP: return "Sony DSP processor";
2236 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2237 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2238 case EM_FX66: return "Siemens FX66 microcontroller";
2239 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2240 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2241 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2242 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2243 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2244 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2245 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2246 case EM_SVX: return "Silicon Graphics SVx";
2247 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2248 case EM_VAX: return "Digital VAX";
2249 case EM_VISIUM: return "CDS VISIUMcore processor";
2250 case EM_AVR_OLD:
2251 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2252 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2253 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2254 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2255 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2256 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2257 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2258 case EM_PRISM: return "Vitesse Prism";
2259 case EM_X86_64: return "Advanced Micro Devices X86-64";
2260 case EM_L1OM: return "Intel L1OM";
2261 case EM_K1OM: return "Intel K1OM";
2262 case EM_S390_OLD:
2263 case EM_S390: return "IBM S/390";
2264 case EM_SCORE: return "SUNPLUS S+Core";
2265 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2266 case EM_OR1K: return "OpenRISC 1000";
2267 case EM_CRX: return "National Semiconductor CRX microprocessor";
2268 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2269 case EM_DLX: return "OpenDLX";
2270 case EM_IP2K_OLD:
2271 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2272 case EM_IQ2000: return "Vitesse IQ2000";
2273 case EM_XTENSA_OLD:
2274 case EM_XTENSA: return "Tensilica Xtensa Processor";
2275 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2276 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2277 case EM_NS32K: return "National Semiconductor 32000 series";
2278 case EM_TPC: return "Tenor Network TPC processor";
2279 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2280 case EM_MAX: return "MAX Processor";
2281 case EM_CR: return "National Semiconductor CompactRISC";
2282 case EM_F2MC16: return "Fujitsu F2MC16";
2283 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2284 case EM_LATTICEMICO32: return "Lattice Mico32";
2285 case EM_M32C_OLD:
2286 case EM_M32C: return "Renesas M32c";
2287 case EM_MT: return "Morpho Techologies MT processor";
2288 case EM_BLACKFIN: return "Analog Devices Blackfin";
2289 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2290 case EM_SEP: return "Sharp embedded microprocessor";
2291 case EM_ARCA: return "Arca RISC microprocessor";
2292 case EM_UNICORE: return "Unicore";
2293 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2294 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2295 case EM_NIOS32: return "Altera Nios";
2296 case EM_ALTERA_NIOS2: return "Altera Nios II";
2297 case EM_C166:
2298 case EM_XC16X: return "Infineon Technologies xc16x";
2299 case EM_M16C: return "Renesas M16C series microprocessors";
2300 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2301 case EM_CE: return "Freescale Communication Engine RISC core";
2302 case EM_TSK3000: return "Altium TSK3000 core";
2303 case EM_RS08: return "Freescale RS08 embedded processor";
2304 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2305 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2306 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2307 case EM_SE_C17: return "Seiko Epson C17 family";
2308 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2309 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2310 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2311 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2312 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2313 case EM_R32C: return "Renesas R32C series microprocessors";
2314 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2315 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2316 case EM_8051: return "Intel 8051 and variants";
2317 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2318 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2319 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2320 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2321 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2322 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2323 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2324 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2325 case EM_CR16:
2326 case EM_MICROBLAZE:
2327 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2328 case EM_RL78: return "Renesas RL78";
2329 case EM_RX: return "Renesas RX";
2330 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2331 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2332 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2333 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2334 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2335 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2336 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2337 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2338 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2339 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2340 case EM_CUDA: return "NVIDIA CUDA architecture";
2341 case EM_XGATE: return "Motorola XGATE embedded processor";
2342 default:
2343 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2344 return buff;
2345 }
2346}
2347
2348static void
2349decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2350{
2351 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2352 other compilers don't a specific architecture type in the e_flags, and
2353 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2354 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2355 architectures.
2356
2357 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2358 but also sets a specific architecture type in the e_flags field.
2359
2360 However, when decoding the flags we don't worry if we see an
2361 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2362 ARCEM architecture type. */
2363
2364 switch (e_flags & EF_ARC_MACH_MSK)
2365 {
2366 /* We only expect these to occur for EM_ARC_COMPACT2. */
2367 case EF_ARC_CPU_ARCV2EM:
2368 strcat (buf, ", ARC EM");
2369 break;
2370 case EF_ARC_CPU_ARCV2HS:
2371 strcat (buf, ", ARC HS");
2372 break;
2373
2374 /* We only expect these to occur for EM_ARC_COMPACT. */
2375 case E_ARC_MACH_ARC600:
2376 strcat (buf, ", ARC600");
2377 break;
2378 case E_ARC_MACH_ARC601:
2379 strcat (buf, ", ARC601");
2380 break;
2381 case E_ARC_MACH_ARC700:
2382 strcat (buf, ", ARC700");
2383 break;
2384
2385 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2386 new ELF with new architecture being read by an old version of
2387 readelf, or (c) An ELF built with non-GNU compiler that does not
2388 set the architecture in the e_flags. */
2389 default:
2390 if (e_machine == EM_ARC_COMPACT)
2391 strcat (buf, ", Unknown ARCompact");
2392 else
2393 strcat (buf, ", Unknown ARC");
2394 break;
2395 }
2396
2397 switch (e_flags & EF_ARC_OSABI_MSK)
2398 {
2399 case E_ARC_OSABI_ORIG:
2400 strcat (buf, ", (ABI:legacy)");
2401 break;
2402 case E_ARC_OSABI_V2:
2403 strcat (buf, ", (ABI:v2)");
2404 break;
2405 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2406 case E_ARC_OSABI_V3:
2407 strcat (buf, ", v3 no-legacy-syscalls ABI");
2408 break;
2409 default:
2410 strcat (buf, ", unrecognised ARC OSABI flag");
2411 break;
2412 }
2413}
2414
2415static void
2416decode_ARM_machine_flags (unsigned e_flags, char buf[])
2417{
2418 unsigned eabi;
2419 int unknown = 0;
2420
2421 eabi = EF_ARM_EABI_VERSION (e_flags);
2422 e_flags &= ~ EF_ARM_EABIMASK;
2423
2424 /* Handle "generic" ARM flags. */
2425 if (e_flags & EF_ARM_RELEXEC)
2426 {
2427 strcat (buf, ", relocatable executable");
2428 e_flags &= ~ EF_ARM_RELEXEC;
2429 }
2430
2431 /* Now handle EABI specific flags. */
2432 switch (eabi)
2433 {
2434 default:
2435 strcat (buf, ", <unrecognized EABI>");
2436 if (e_flags)
2437 unknown = 1;
2438 break;
2439
2440 case EF_ARM_EABI_VER1:
2441 strcat (buf, ", Version1 EABI");
2442 while (e_flags)
2443 {
2444 unsigned flag;
2445
2446 /* Process flags one bit at a time. */
2447 flag = e_flags & - e_flags;
2448 e_flags &= ~ flag;
2449
2450 switch (flag)
2451 {
2452 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2453 strcat (buf, ", sorted symbol tables");
2454 break;
2455
2456 default:
2457 unknown = 1;
2458 break;
2459 }
2460 }
2461 break;
2462
2463 case EF_ARM_EABI_VER2:
2464 strcat (buf, ", Version2 EABI");
2465 while (e_flags)
2466 {
2467 unsigned flag;
2468
2469 /* Process flags one bit at a time. */
2470 flag = e_flags & - e_flags;
2471 e_flags &= ~ flag;
2472
2473 switch (flag)
2474 {
2475 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2476 strcat (buf, ", sorted symbol tables");
2477 break;
2478
2479 case EF_ARM_DYNSYMSUSESEGIDX:
2480 strcat (buf, ", dynamic symbols use segment index");
2481 break;
2482
2483 case EF_ARM_MAPSYMSFIRST:
2484 strcat (buf, ", mapping symbols precede others");
2485 break;
2486
2487 default:
2488 unknown = 1;
2489 break;
2490 }
2491 }
2492 break;
2493
2494 case EF_ARM_EABI_VER3:
2495 strcat (buf, ", Version3 EABI");
2496 break;
2497
2498 case EF_ARM_EABI_VER4:
2499 strcat (buf, ", Version4 EABI");
2500 while (e_flags)
2501 {
2502 unsigned flag;
2503
2504 /* Process flags one bit at a time. */
2505 flag = e_flags & - e_flags;
2506 e_flags &= ~ flag;
2507
2508 switch (flag)
2509 {
2510 case EF_ARM_BE8:
2511 strcat (buf, ", BE8");
2512 break;
2513
2514 case EF_ARM_LE8:
2515 strcat (buf, ", LE8");
2516 break;
2517
2518 default:
2519 unknown = 1;
2520 break;
2521 }
2522 break;
2523 }
2524 break;
2525
2526 case EF_ARM_EABI_VER5:
2527 strcat (buf, ", Version5 EABI");
2528 while (e_flags)
2529 {
2530 unsigned flag;
2531
2532 /* Process flags one bit at a time. */
2533 flag = e_flags & - e_flags;
2534 e_flags &= ~ flag;
2535
2536 switch (flag)
2537 {
2538 case EF_ARM_BE8:
2539 strcat (buf, ", BE8");
2540 break;
2541
2542 case EF_ARM_LE8:
2543 strcat (buf, ", LE8");
2544 break;
2545
2546 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2547 strcat (buf, ", soft-float ABI");
2548 break;
2549
2550 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2551 strcat (buf, ", hard-float ABI");
2552 break;
2553
2554 default:
2555 unknown = 1;
2556 break;
2557 }
2558 }
2559 break;
2560
2561 case EF_ARM_EABI_UNKNOWN:
2562 strcat (buf, ", GNU EABI");
2563 while (e_flags)
2564 {
2565 unsigned flag;
2566
2567 /* Process flags one bit at a time. */
2568 flag = e_flags & - e_flags;
2569 e_flags &= ~ flag;
2570
2571 switch (flag)
2572 {
2573 case EF_ARM_INTERWORK:
2574 strcat (buf, ", interworking enabled");
2575 break;
2576
2577 case EF_ARM_APCS_26:
2578 strcat (buf, ", uses APCS/26");
2579 break;
2580
2581 case EF_ARM_APCS_FLOAT:
2582 strcat (buf, ", uses APCS/float");
2583 break;
2584
2585 case EF_ARM_PIC:
2586 strcat (buf, ", position independent");
2587 break;
2588
2589 case EF_ARM_ALIGN8:
2590 strcat (buf, ", 8 bit structure alignment");
2591 break;
2592
2593 case EF_ARM_NEW_ABI:
2594 strcat (buf, ", uses new ABI");
2595 break;
2596
2597 case EF_ARM_OLD_ABI:
2598 strcat (buf, ", uses old ABI");
2599 break;
2600
2601 case EF_ARM_SOFT_FLOAT:
2602 strcat (buf, ", software FP");
2603 break;
2604
2605 case EF_ARM_VFP_FLOAT:
2606 strcat (buf, ", VFP");
2607 break;
2608
2609 case EF_ARM_MAVERICK_FLOAT:
2610 strcat (buf, ", Maverick FP");
2611 break;
2612
2613 default:
2614 unknown = 1;
2615 break;
2616 }
2617 }
2618 }
2619
2620 if (unknown)
2621 strcat (buf,_(", <unknown>"));
2622}
2623
2624static void
2625decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2626{
2627 --size; /* Leave space for null terminator. */
2628
2629 switch (e_flags & EF_AVR_MACH)
2630 {
2631 case E_AVR_MACH_AVR1:
2632 strncat (buf, ", avr:1", size);
2633 break;
2634 case E_AVR_MACH_AVR2:
2635 strncat (buf, ", avr:2", size);
2636 break;
2637 case E_AVR_MACH_AVR25:
2638 strncat (buf, ", avr:25", size);
2639 break;
2640 case E_AVR_MACH_AVR3:
2641 strncat (buf, ", avr:3", size);
2642 break;
2643 case E_AVR_MACH_AVR31:
2644 strncat (buf, ", avr:31", size);
2645 break;
2646 case E_AVR_MACH_AVR35:
2647 strncat (buf, ", avr:35", size);
2648 break;
2649 case E_AVR_MACH_AVR4:
2650 strncat (buf, ", avr:4", size);
2651 break;
2652 case E_AVR_MACH_AVR5:
2653 strncat (buf, ", avr:5", size);
2654 break;
2655 case E_AVR_MACH_AVR51:
2656 strncat (buf, ", avr:51", size);
2657 break;
2658 case E_AVR_MACH_AVR6:
2659 strncat (buf, ", avr:6", size);
2660 break;
2661 case E_AVR_MACH_AVRTINY:
2662 strncat (buf, ", avr:100", size);
2663 break;
2664 case E_AVR_MACH_XMEGA1:
2665 strncat (buf, ", avr:101", size);
2666 break;
2667 case E_AVR_MACH_XMEGA2:
2668 strncat (buf, ", avr:102", size);
2669 break;
2670 case E_AVR_MACH_XMEGA3:
2671 strncat (buf, ", avr:103", size);
2672 break;
2673 case E_AVR_MACH_XMEGA4:
2674 strncat (buf, ", avr:104", size);
2675 break;
2676 case E_AVR_MACH_XMEGA5:
2677 strncat (buf, ", avr:105", size);
2678 break;
2679 case E_AVR_MACH_XMEGA6:
2680 strncat (buf, ", avr:106", size);
2681 break;
2682 case E_AVR_MACH_XMEGA7:
2683 strncat (buf, ", avr:107", size);
2684 break;
2685 default:
2686 strncat (buf, ", avr:<unknown>", size);
2687 break;
2688 }
2689
2690 size -= strlen (buf);
2691 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2692 strncat (buf, ", link-relax", size);
2693}
2694
2695static void
2696decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2697{
2698 unsigned abi;
2699 unsigned arch;
2700 unsigned config;
2701 unsigned version;
2702 int has_fpu = 0;
2703 int r = 0;
2704
2705 static const char *ABI_STRINGS[] =
2706 {
2707 "ABI v0", /* use r5 as return register; only used in N1213HC */
2708 "ABI v1", /* use r0 as return register */
2709 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2710 "ABI v2fp", /* for FPU */
2711 "AABI",
2712 "ABI2 FP+"
2713 };
2714 static const char *VER_STRINGS[] =
2715 {
2716 "Andes ELF V1.3 or older",
2717 "Andes ELF V1.3.1",
2718 "Andes ELF V1.4"
2719 };
2720 static const char *ARCH_STRINGS[] =
2721 {
2722 "",
2723 "Andes Star v1.0",
2724 "Andes Star v2.0",
2725 "Andes Star v3.0",
2726 "Andes Star v3.0m"
2727 };
2728
2729 abi = EF_NDS_ABI & e_flags;
2730 arch = EF_NDS_ARCH & e_flags;
2731 config = EF_NDS_INST & e_flags;
2732 version = EF_NDS32_ELF_VERSION & e_flags;
2733
2734 memset (buf, 0, size);
2735
2736 switch (abi)
2737 {
2738 case E_NDS_ABI_V0:
2739 case E_NDS_ABI_V1:
2740 case E_NDS_ABI_V2:
2741 case E_NDS_ABI_V2FP:
2742 case E_NDS_ABI_AABI:
2743 case E_NDS_ABI_V2FP_PLUS:
2744 /* In case there are holes in the array. */
2745 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2746 break;
2747
2748 default:
2749 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2750 break;
2751 }
2752
2753 switch (version)
2754 {
2755 case E_NDS32_ELF_VER_1_2:
2756 case E_NDS32_ELF_VER_1_3:
2757 case E_NDS32_ELF_VER_1_4:
2758 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2759 break;
2760
2761 default:
2762 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2763 break;
2764 }
2765
2766 if (E_NDS_ABI_V0 == abi)
2767 {
2768 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2769 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2770 if (arch == E_NDS_ARCH_STAR_V1_0)
2771 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2772 return;
2773 }
2774
2775 switch (arch)
2776 {
2777 case E_NDS_ARCH_STAR_V1_0:
2778 case E_NDS_ARCH_STAR_V2_0:
2779 case E_NDS_ARCH_STAR_V3_0:
2780 case E_NDS_ARCH_STAR_V3_M:
2781 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2782 break;
2783
2784 default:
2785 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2786 /* ARCH version determines how the e_flags are interpreted.
2787 If it is unknown, we cannot proceed. */
2788 return;
2789 }
2790
2791 /* Newer ABI; Now handle architecture specific flags. */
2792 if (arch == E_NDS_ARCH_STAR_V1_0)
2793 {
2794 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2795 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2796
2797 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2798 r += snprintf (buf + r, size -r, ", MAC");
2799
2800 if (config & E_NDS32_HAS_DIV_INST)
2801 r += snprintf (buf + r, size -r, ", DIV");
2802
2803 if (config & E_NDS32_HAS_16BIT_INST)
2804 r += snprintf (buf + r, size -r, ", 16b");
2805 }
2806 else
2807 {
2808 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2809 {
2810 if (version <= E_NDS32_ELF_VER_1_3)
2811 r += snprintf (buf + r, size -r, ", [B8]");
2812 else
2813 r += snprintf (buf + r, size -r, ", EX9");
2814 }
2815
2816 if (config & E_NDS32_HAS_MAC_DX_INST)
2817 r += snprintf (buf + r, size -r, ", MAC_DX");
2818
2819 if (config & E_NDS32_HAS_DIV_DX_INST)
2820 r += snprintf (buf + r, size -r, ", DIV_DX");
2821
2822 if (config & E_NDS32_HAS_16BIT_INST)
2823 {
2824 if (version <= E_NDS32_ELF_VER_1_3)
2825 r += snprintf (buf + r, size -r, ", 16b");
2826 else
2827 r += snprintf (buf + r, size -r, ", IFC");
2828 }
2829 }
2830
2831 if (config & E_NDS32_HAS_EXT_INST)
2832 r += snprintf (buf + r, size -r, ", PERF1");
2833
2834 if (config & E_NDS32_HAS_EXT2_INST)
2835 r += snprintf (buf + r, size -r, ", PERF2");
2836
2837 if (config & E_NDS32_HAS_FPU_INST)
2838 {
2839 has_fpu = 1;
2840 r += snprintf (buf + r, size -r, ", FPU_SP");
2841 }
2842
2843 if (config & E_NDS32_HAS_FPU_DP_INST)
2844 {
2845 has_fpu = 1;
2846 r += snprintf (buf + r, size -r, ", FPU_DP");
2847 }
2848
2849 if (config & E_NDS32_HAS_FPU_MAC_INST)
2850 {
2851 has_fpu = 1;
2852 r += snprintf (buf + r, size -r, ", FPU_MAC");
2853 }
2854
2855 if (has_fpu)
2856 {
2857 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2858 {
2859 case E_NDS32_FPU_REG_8SP_4DP:
2860 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2861 break;
2862 case E_NDS32_FPU_REG_16SP_8DP:
2863 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2864 break;
2865 case E_NDS32_FPU_REG_32SP_16DP:
2866 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2867 break;
2868 case E_NDS32_FPU_REG_32SP_32DP:
2869 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2870 break;
2871 }
2872 }
2873
2874 if (config & E_NDS32_HAS_AUDIO_INST)
2875 r += snprintf (buf + r, size -r, ", AUDIO");
2876
2877 if (config & E_NDS32_HAS_STRING_INST)
2878 r += snprintf (buf + r, size -r, ", STR");
2879
2880 if (config & E_NDS32_HAS_REDUCED_REGS)
2881 r += snprintf (buf + r, size -r, ", 16REG");
2882
2883 if (config & E_NDS32_HAS_VIDEO_INST)
2884 {
2885 if (version <= E_NDS32_ELF_VER_1_3)
2886 r += snprintf (buf + r, size -r, ", VIDEO");
2887 else
2888 r += snprintf (buf + r, size -r, ", SATURATION");
2889 }
2890
2891 if (config & E_NDS32_HAS_ENCRIPT_INST)
2892 r += snprintf (buf + r, size -r, ", ENCRP");
2893
2894 if (config & E_NDS32_HAS_L2C_INST)
2895 r += snprintf (buf + r, size -r, ", L2C");
2896}
2897
2898static char *
2899get_machine_flags (unsigned e_flags, unsigned e_machine)
2900{
2901 static char buf[1024];
2902
2903 buf[0] = '\0';
2904
2905 if (e_flags)
2906 {
2907 switch (e_machine)
2908 {
2909 default:
2910 break;
2911
2912 case EM_ARC_COMPACT2:
2913 case EM_ARC_COMPACT:
2914 decode_ARC_machine_flags (e_flags, e_machine, buf);
2915 break;
2916
2917 case EM_ARM:
2918 decode_ARM_machine_flags (e_flags, buf);
2919 break;
2920
2921 case EM_AVR:
2922 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2923 break;
2924
2925 case EM_BLACKFIN:
2926 if (e_flags & EF_BFIN_PIC)
2927 strcat (buf, ", PIC");
2928
2929 if (e_flags & EF_BFIN_FDPIC)
2930 strcat (buf, ", FDPIC");
2931
2932 if (e_flags & EF_BFIN_CODE_IN_L1)
2933 strcat (buf, ", code in L1");
2934
2935 if (e_flags & EF_BFIN_DATA_IN_L1)
2936 strcat (buf, ", data in L1");
2937
2938 break;
2939
2940 case EM_CYGNUS_FRV:
2941 switch (e_flags & EF_FRV_CPU_MASK)
2942 {
2943 case EF_FRV_CPU_GENERIC:
2944 break;
2945
2946 default:
2947 strcat (buf, ", fr???");
2948 break;
2949
2950 case EF_FRV_CPU_FR300:
2951 strcat (buf, ", fr300");
2952 break;
2953
2954 case EF_FRV_CPU_FR400:
2955 strcat (buf, ", fr400");
2956 break;
2957 case EF_FRV_CPU_FR405:
2958 strcat (buf, ", fr405");
2959 break;
2960
2961 case EF_FRV_CPU_FR450:
2962 strcat (buf, ", fr450");
2963 break;
2964
2965 case EF_FRV_CPU_FR500:
2966 strcat (buf, ", fr500");
2967 break;
2968 case EF_FRV_CPU_FR550:
2969 strcat (buf, ", fr550");
2970 break;
2971
2972 case EF_FRV_CPU_SIMPLE:
2973 strcat (buf, ", simple");
2974 break;
2975 case EF_FRV_CPU_TOMCAT:
2976 strcat (buf, ", tomcat");
2977 break;
2978 }
2979 break;
2980
2981 case EM_68K:
2982 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2983 strcat (buf, ", m68000");
2984 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2985 strcat (buf, ", cpu32");
2986 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2987 strcat (buf, ", fido_a");
2988 else
2989 {
2990 char const * isa = _("unknown");
2991 char const * mac = _("unknown mac");
2992 char const * additional = NULL;
2993
2994 switch (e_flags & EF_M68K_CF_ISA_MASK)
2995 {
2996 case EF_M68K_CF_ISA_A_NODIV:
2997 isa = "A";
2998 additional = ", nodiv";
2999 break;
3000 case EF_M68K_CF_ISA_A:
3001 isa = "A";
3002 break;
3003 case EF_M68K_CF_ISA_A_PLUS:
3004 isa = "A+";
3005 break;
3006 case EF_M68K_CF_ISA_B_NOUSP:
3007 isa = "B";
3008 additional = ", nousp";
3009 break;
3010 case EF_M68K_CF_ISA_B:
3011 isa = "B";
3012 break;
3013 case EF_M68K_CF_ISA_C:
3014 isa = "C";
3015 break;
3016 case EF_M68K_CF_ISA_C_NODIV:
3017 isa = "C";
3018 additional = ", nodiv";
3019 break;
3020 }
3021 strcat (buf, ", cf, isa ");
3022 strcat (buf, isa);
3023 if (additional)
3024 strcat (buf, additional);
3025 if (e_flags & EF_M68K_CF_FLOAT)
3026 strcat (buf, ", float");
3027 switch (e_flags & EF_M68K_CF_MAC_MASK)
3028 {
3029 case 0:
3030 mac = NULL;
3031 break;
3032 case EF_M68K_CF_MAC:
3033 mac = "mac";
3034 break;
3035 case EF_M68K_CF_EMAC:
3036 mac = "emac";
3037 break;
3038 case EF_M68K_CF_EMAC_B:
3039 mac = "emac_b";
3040 break;
3041 }
3042 if (mac)
3043 {
3044 strcat (buf, ", ");
3045 strcat (buf, mac);
3046 }
3047 }
3048 break;
3049
3050 case EM_CYGNUS_MEP:
3051 switch (e_flags & EF_MEP_CPU_MASK)
3052 {
3053 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3054 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3055 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3056 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3057 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3058 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3059 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3060 }
3061
3062 switch (e_flags & EF_MEP_COP_MASK)
3063 {
3064 case EF_MEP_COP_NONE: break;
3065 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3066 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3067 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3068 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3069 default: strcat (buf, _("<unknown MeP copro type>")); break;
3070 }
3071
3072 if (e_flags & EF_MEP_LIBRARY)
3073 strcat (buf, ", Built for Library");
3074
3075 if (e_flags & EF_MEP_INDEX_MASK)
3076 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3077 e_flags & EF_MEP_INDEX_MASK);
3078
3079 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3080 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3081 e_flags & ~ EF_MEP_ALL_FLAGS);
3082 break;
3083
3084 case EM_PPC:
3085 if (e_flags & EF_PPC_EMB)
3086 strcat (buf, ", emb");
3087
3088 if (e_flags & EF_PPC_RELOCATABLE)
3089 strcat (buf, _(", relocatable"));
3090
3091 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3092 strcat (buf, _(", relocatable-lib"));
3093 break;
3094
3095 case EM_PPC64:
3096 if (e_flags & EF_PPC64_ABI)
3097 {
3098 char abi[] = ", abiv0";
3099
3100 abi[6] += e_flags & EF_PPC64_ABI;
3101 strcat (buf, abi);
3102 }
3103 break;
3104
3105 case EM_V800:
3106 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3107 strcat (buf, ", RH850 ABI");
3108
3109 if (e_flags & EF_V800_850E3)
3110 strcat (buf, ", V3 architecture");
3111
3112 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3113 strcat (buf, ", FPU not used");
3114
3115 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3116 strcat (buf, ", regmode: COMMON");
3117
3118 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3119 strcat (buf, ", r4 not used");
3120
3121 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3122 strcat (buf, ", r30 not used");
3123
3124 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3125 strcat (buf, ", r5 not used");
3126
3127 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3128 strcat (buf, ", r2 not used");
3129
3130 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3131 {
3132 switch (e_flags & - e_flags)
3133 {
3134 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3135 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3136 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3137 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3138 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3139 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3140 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3141 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3142 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3143 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3144 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3145 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3146 default: break;
3147 }
3148 }
3149 break;
3150
3151 case EM_V850:
3152 case EM_CYGNUS_V850:
3153 switch (e_flags & EF_V850_ARCH)
3154 {
3155 case E_V850E3V5_ARCH:
3156 strcat (buf, ", v850e3v5");
3157 break;
3158 case E_V850E2V3_ARCH:
3159 strcat (buf, ", v850e2v3");
3160 break;
3161 case E_V850E2_ARCH:
3162 strcat (buf, ", v850e2");
3163 break;
3164 case E_V850E1_ARCH:
3165 strcat (buf, ", v850e1");
3166 break;
3167 case E_V850E_ARCH:
3168 strcat (buf, ", v850e");
3169 break;
3170 case E_V850_ARCH:
3171 strcat (buf, ", v850");
3172 break;
3173 default:
3174 strcat (buf, _(", unknown v850 architecture variant"));
3175 break;
3176 }
3177 break;
3178
3179 case EM_M32R:
3180 case EM_CYGNUS_M32R:
3181 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3182 strcat (buf, ", m32r");
3183 break;
3184
3185 case EM_MIPS:
3186 case EM_MIPS_RS3_LE:
3187 if (e_flags & EF_MIPS_NOREORDER)
3188 strcat (buf, ", noreorder");
3189
3190 if (e_flags & EF_MIPS_PIC)
3191 strcat (buf, ", pic");
3192
3193 if (e_flags & EF_MIPS_CPIC)
3194 strcat (buf, ", cpic");
3195
3196 if (e_flags & EF_MIPS_UCODE)
3197 strcat (buf, ", ugen_reserved");
3198
3199 if (e_flags & EF_MIPS_ABI2)
3200 strcat (buf, ", abi2");
3201
3202 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3203 strcat (buf, ", odk first");
3204
3205 if (e_flags & EF_MIPS_32BITMODE)
3206 strcat (buf, ", 32bitmode");
3207
3208 if (e_flags & EF_MIPS_NAN2008)
3209 strcat (buf, ", nan2008");
3210
3211 if (e_flags & EF_MIPS_FP64)
3212 strcat (buf, ", fp64");
3213
3214 switch ((e_flags & EF_MIPS_MACH))
3215 {
3216 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3217 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3218 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3219 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3220 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3221 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3222 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3223 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3224 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3225 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3226 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3227 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3228 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3229 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3230 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3231 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3232 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3233 case 0:
3234 /* We simply ignore the field in this case to avoid confusion:
3235 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3236 extension. */
3237 break;
3238 default: strcat (buf, _(", unknown CPU")); break;
3239 }
3240
3241 switch ((e_flags & EF_MIPS_ABI))
3242 {
3243 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3244 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3245 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3246 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3247 case 0:
3248 /* We simply ignore the field in this case to avoid confusion:
3249 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3250 This means it is likely to be an o32 file, but not for
3251 sure. */
3252 break;
3253 default: strcat (buf, _(", unknown ABI")); break;
3254 }
3255
3256 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3257 strcat (buf, ", mdmx");
3258
3259 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3260 strcat (buf, ", mips16");
3261
3262 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3263 strcat (buf, ", micromips");
3264
3265 switch ((e_flags & EF_MIPS_ARCH))
3266 {
3267 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3268 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3269 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3270 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3271 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3272 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3273 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3274 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3275 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3276 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3277 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3278 default: strcat (buf, _(", unknown ISA")); break;
3279 }
3280 break;
3281
3282 case EM_NDS32:
3283 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3284 break;
3285
3286 case EM_SH:
3287 switch ((e_flags & EF_SH_MACH_MASK))
3288 {
3289 case EF_SH1: strcat (buf, ", sh1"); break;
3290 case EF_SH2: strcat (buf, ", sh2"); break;
3291 case EF_SH3: strcat (buf, ", sh3"); break;
3292 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3293 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3294 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3295 case EF_SH3E: strcat (buf, ", sh3e"); break;
3296 case EF_SH4: strcat (buf, ", sh4"); break;
3297 case EF_SH5: strcat (buf, ", sh5"); break;
3298 case EF_SH2E: strcat (buf, ", sh2e"); break;
3299 case EF_SH4A: strcat (buf, ", sh4a"); break;
3300 case EF_SH2A: strcat (buf, ", sh2a"); break;
3301 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3302 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3303 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3304 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3305 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3306 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3307 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3308 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3309 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3310 default: strcat (buf, _(", unknown ISA")); break;
3311 }
3312
3313 if (e_flags & EF_SH_PIC)
3314 strcat (buf, ", pic");
3315
3316 if (e_flags & EF_SH_FDPIC)
3317 strcat (buf, ", fdpic");
3318 break;
3319
3320 case EM_OR1K:
3321 if (e_flags & EF_OR1K_NODELAY)
3322 strcat (buf, ", no delay");
3323 break;
3324
3325 case EM_SPARCV9:
3326 if (e_flags & EF_SPARC_32PLUS)
3327 strcat (buf, ", v8+");
3328
3329 if (e_flags & EF_SPARC_SUN_US1)
3330 strcat (buf, ", ultrasparcI");
3331
3332 if (e_flags & EF_SPARC_SUN_US3)
3333 strcat (buf, ", ultrasparcIII");
3334
3335 if (e_flags & EF_SPARC_HAL_R1)
3336 strcat (buf, ", halr1");
3337
3338 if (e_flags & EF_SPARC_LEDATA)
3339 strcat (buf, ", ledata");
3340
3341 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3342 strcat (buf, ", tso");
3343
3344 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3345 strcat (buf, ", pso");
3346
3347 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3348 strcat (buf, ", rmo");
3349 break;
3350
3351 case EM_PARISC:
3352 switch (e_flags & EF_PARISC_ARCH)
3353 {
3354 case EFA_PARISC_1_0:
3355 strcpy (buf, ", PA-RISC 1.0");
3356 break;
3357 case EFA_PARISC_1_1:
3358 strcpy (buf, ", PA-RISC 1.1");
3359 break;
3360 case EFA_PARISC_2_0:
3361 strcpy (buf, ", PA-RISC 2.0");
3362 break;
3363 default:
3364 break;
3365 }
3366 if (e_flags & EF_PARISC_TRAPNIL)
3367 strcat (buf, ", trapnil");
3368 if (e_flags & EF_PARISC_EXT)
3369 strcat (buf, ", ext");
3370 if (e_flags & EF_PARISC_LSB)
3371 strcat (buf, ", lsb");
3372 if (e_flags & EF_PARISC_WIDE)
3373 strcat (buf, ", wide");
3374 if (e_flags & EF_PARISC_NO_KABP)
3375 strcat (buf, ", no kabp");
3376 if (e_flags & EF_PARISC_LAZYSWAP)
3377 strcat (buf, ", lazyswap");
3378 break;
3379
3380 case EM_PJ:
3381 case EM_PJ_OLD:
3382 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3383 strcat (buf, ", new calling convention");
3384
3385 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3386 strcat (buf, ", gnu calling convention");
3387 break;
3388
3389 case EM_IA_64:
3390 if ((e_flags & EF_IA_64_ABI64))
3391 strcat (buf, ", 64-bit");
3392 else
3393 strcat (buf, ", 32-bit");
3394 if ((e_flags & EF_IA_64_REDUCEDFP))
3395 strcat (buf, ", reduced fp model");
3396 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3397 strcat (buf, ", no function descriptors, constant gp");
3398 else if ((e_flags & EF_IA_64_CONS_GP))
3399 strcat (buf, ", constant gp");
3400 if ((e_flags & EF_IA_64_ABSOLUTE))
3401 strcat (buf, ", absolute");
3402 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3403 {
3404 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3405 strcat (buf, ", vms_linkages");
3406 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3407 {
3408 case EF_IA_64_VMS_COMCOD_SUCCESS:
3409 break;
3410 case EF_IA_64_VMS_COMCOD_WARNING:
3411 strcat (buf, ", warning");
3412 break;
3413 case EF_IA_64_VMS_COMCOD_ERROR:
3414 strcat (buf, ", error");
3415 break;
3416 case EF_IA_64_VMS_COMCOD_ABORT:
3417 strcat (buf, ", abort");
3418 break;
3419 default:
3420 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3421 e_flags & EF_IA_64_VMS_COMCOD);
3422 strcat (buf, ", <unknown>");
3423 }
3424 }
3425 break;
3426
3427 case EM_VAX:
3428 if ((e_flags & EF_VAX_NONPIC))
3429 strcat (buf, ", non-PIC");
3430 if ((e_flags & EF_VAX_DFLOAT))
3431 strcat (buf, ", D-Float");
3432 if ((e_flags & EF_VAX_GFLOAT))
3433 strcat (buf, ", G-Float");
3434 break;
3435
3436 case EM_VISIUM:
3437 if (e_flags & EF_VISIUM_ARCH_MCM)
3438 strcat (buf, ", mcm");
3439 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3440 strcat (buf, ", mcm24");
3441 if (e_flags & EF_VISIUM_ARCH_GR6)
3442 strcat (buf, ", gr6");
3443 break;
3444
3445 case EM_RL78:
3446 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3447 {
3448 case E_FLAG_RL78_ANY_CPU: break;
3449 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3450 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3451 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3452 }
3453 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3454 strcat (buf, ", 64-bit doubles");
3455 break;
3456
3457 case EM_RX:
3458 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3459 strcat (buf, ", 64-bit doubles");
3460 if (e_flags & E_FLAG_RX_DSP)
3461 strcat (buf, ", dsp");
3462 if (e_flags & E_FLAG_RX_PID)
3463 strcat (buf, ", pid");
3464 if (e_flags & E_FLAG_RX_ABI)
3465 strcat (buf, ", RX ABI");
3466 if (e_flags & E_FLAG_RX_SINSNS_SET)
3467 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3468 ? ", uses String instructions" : ", bans String instructions");
3469 if (e_flags & E_FLAG_RX_V2)
3470 strcat (buf, ", V2");
3471 break;
3472
3473 case EM_S390:
3474 if (e_flags & EF_S390_HIGH_GPRS)
3475 strcat (buf, ", highgprs");
3476 break;
3477
3478 case EM_TI_C6000:
3479 if ((e_flags & EF_C6000_REL))
3480 strcat (buf, ", relocatable module");
3481 break;
3482
3483 case EM_MSP430:
3484 strcat (buf, _(": architecture variant: "));
3485 switch (e_flags & EF_MSP430_MACH)
3486 {
3487 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3488 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3489 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3490 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3491 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3492 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3493 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3494 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3495 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3496 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3497 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3498 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3499 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3500 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3501 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3502 default:
3503 strcat (buf, _(": unknown")); break;
3504 }
3505
3506 if (e_flags & ~ EF_MSP430_MACH)
3507 strcat (buf, _(": unknown extra flag bits also present"));
3508 }
3509 }
3510
3511 return buf;
3512}
3513
3514static const char *
3515get_osabi_name (unsigned int osabi)
3516{
3517 static char buff[32];
3518
3519 switch (osabi)
3520 {
3521 case ELFOSABI_NONE: return "UNIX - System V";
3522 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3523 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3524 case ELFOSABI_GNU: return "UNIX - GNU";
3525 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3526 case ELFOSABI_AIX: return "UNIX - AIX";
3527 case ELFOSABI_IRIX: return "UNIX - IRIX";
3528 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3529 case ELFOSABI_TRU64: return "UNIX - TRU64";
3530 case ELFOSABI_MODESTO: return "Novell - Modesto";
3531 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3532 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3533 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3534 case ELFOSABI_AROS: return "AROS";
3535 case ELFOSABI_FENIXOS: return "FenixOS";
3536 default:
3537 if (osabi >= 64)
3538 switch (elf_header.e_machine)
3539 {
3540 case EM_ARM:
3541 switch (osabi)
3542 {
3543 case ELFOSABI_ARM: return "ARM";
3544 default:
3545 break;
3546 }
3547 break;
3548
3549 case EM_MSP430:
3550 case EM_MSP430_OLD:
3551 case EM_VISIUM:
3552 switch (osabi)
3553 {
3554 case ELFOSABI_STANDALONE: return _("Standalone App");
3555 default:
3556 break;
3557 }
3558 break;
3559
3560 case EM_TI_C6000:
3561 switch (osabi)
3562 {
3563 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3564 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3565 default:
3566 break;
3567 }
3568 break;
3569
3570 default:
3571 break;
3572 }
3573 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3574 return buff;
3575 }
3576}
3577
3578static const char *
3579get_aarch64_segment_type (unsigned long type)
3580{
3581 switch (type)
3582 {
3583 case PT_AARCH64_ARCHEXT:
3584 return "AARCH64_ARCHEXT";
3585 default:
3586 break;
3587 }
3588
3589 return NULL;
3590}
3591
3592static const char *
3593get_arm_segment_type (unsigned long type)
3594{
3595 switch (type)
3596 {
3597 case PT_ARM_EXIDX:
3598 return "EXIDX";
3599 default:
3600 break;
3601 }
3602
3603 return NULL;
3604}
3605
3606static const char *
3607get_mips_segment_type (unsigned long type)
3608{
3609 switch (type)
3610 {
3611 case PT_MIPS_REGINFO:
3612 return "REGINFO";
3613 case PT_MIPS_RTPROC:
3614 return "RTPROC";
3615 case PT_MIPS_OPTIONS:
3616 return "OPTIONS";
3617 case PT_MIPS_ABIFLAGS:
3618 return "ABIFLAGS";
3619 default:
3620 break;
3621 }
3622
3623 return NULL;
3624}
3625
3626static const char *
3627get_parisc_segment_type (unsigned long type)
3628{
3629 switch (type)
3630 {
3631 case PT_HP_TLS: return "HP_TLS";
3632 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3633 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3634 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3635 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3636 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3637 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3638 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3639 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3640 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3641 case PT_HP_PARALLEL: return "HP_PARALLEL";
3642 case PT_HP_FASTBIND: return "HP_FASTBIND";
3643 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3644 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3645 case PT_HP_STACK: return "HP_STACK";
3646 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3647 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3648 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3649 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3650 default:
3651 break;
3652 }
3653
3654 return NULL;
3655}
3656
3657static const char *
3658get_ia64_segment_type (unsigned long type)
3659{
3660 switch (type)
3661 {
3662 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3663 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3664 case PT_HP_TLS: return "HP_TLS";
3665 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3666 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3667 case PT_IA_64_HP_STACK: return "HP_STACK";
3668 default:
3669 break;
3670 }
3671
3672 return NULL;
3673}
3674
3675static const char *
3676get_tic6x_segment_type (unsigned long type)
3677{
3678 switch (type)
3679 {
3680 case PT_C6000_PHATTR: return "C6000_PHATTR";
3681 default:
3682 break;
3683 }
3684
3685 return NULL;
3686}
3687
3688static const char *
3689get_solaris_segment_type (unsigned long type)
3690{
3691 switch (type)
3692 {
3693 case 0x6464e550: return "PT_SUNW_UNWIND";
3694 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3695 case 0x6ffffff7: return "PT_LOSUNW";
3696 case 0x6ffffffa: return "PT_SUNWBSS";
3697 case 0x6ffffffb: return "PT_SUNWSTACK";
3698 case 0x6ffffffc: return "PT_SUNWDTRACE";
3699 case 0x6ffffffd: return "PT_SUNWCAP";
3700 case 0x6fffffff: return "PT_HISUNW";
3701 default: return NULL;
3702 }
3703}
3704
3705static const char *
3706get_segment_type (unsigned long p_type)
3707{
3708 static char buff[32];
3709
3710 switch (p_type)
3711 {
3712 case PT_NULL: return "NULL";
3713 case PT_LOAD: return "LOAD";
3714 case PT_DYNAMIC: return "DYNAMIC";
3715 case PT_INTERP: return "INTERP";
3716 case PT_NOTE: return "NOTE";
3717 case PT_SHLIB: return "SHLIB";
3718 case PT_PHDR: return "PHDR";
3719 case PT_TLS: return "TLS";
3720
3721 case PT_GNU_EH_FRAME:
3722 return "GNU_EH_FRAME";
3723 case PT_GNU_STACK: return "GNU_STACK";
3724 case PT_GNU_RELRO: return "GNU_RELRO";
3725
3726 default:
3727 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3728 {
3729 const char * result;
3730
3731 switch (elf_header.e_machine)
3732 {
3733 case EM_AARCH64:
3734 result = get_aarch64_segment_type (p_type);
3735 break;
3736 case EM_ARM:
3737 result = get_arm_segment_type (p_type);
3738 break;
3739 case EM_MIPS:
3740 case EM_MIPS_RS3_LE:
3741 result = get_mips_segment_type (p_type);
3742 break;
3743 case EM_PARISC:
3744 result = get_parisc_segment_type (p_type);
3745 break;
3746 case EM_IA_64:
3747 result = get_ia64_segment_type (p_type);
3748 break;
3749 case EM_TI_C6000:
3750 result = get_tic6x_segment_type (p_type);
3751 break;
3752 default:
3753 result = NULL;
3754 break;
3755 }
3756
3757 if (result != NULL)
3758 return result;
3759
3760 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3761 }
3762 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3763 {
3764 const char * result;
3765
3766 switch (elf_header.e_machine)
3767 {
3768 case EM_PARISC:
3769 result = get_parisc_segment_type (p_type);
3770 break;
3771 case EM_IA_64:
3772 result = get_ia64_segment_type (p_type);
3773 break;
3774 default:
3775 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3776 result = get_solaris_segment_type (p_type);
3777 else
3778 result = NULL;
3779 break;
3780 }
3781
3782 if (result != NULL)
3783 return result;
3784
3785 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3786 }
3787 else
3788 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3789
3790 return buff;
3791 }
3792}
3793
3794static const char *
3795get_mips_section_type_name (unsigned int sh_type)
3796{
3797 switch (sh_type)
3798 {
3799 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3800 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3801 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3802 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3803 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3804 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3805 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3806 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3807 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3808 case SHT_MIPS_RELD: return "MIPS_RELD";
3809 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3810 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3811 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3812 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3813 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3814 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3815 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3816 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3817 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3818 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3819 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3820 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3821 case SHT_MIPS_LINE: return "MIPS_LINE";
3822 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3823 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3824 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3825 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3826 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3827 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3828 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3829 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3830 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3831 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3832 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3833 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3834 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3835 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3836 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3837 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3838 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3839 default:
3840 break;
3841 }
3842 return NULL;
3843}
3844
3845static const char *
3846get_parisc_section_type_name (unsigned int sh_type)
3847{
3848 switch (sh_type)
3849 {
3850 case SHT_PARISC_EXT: return "PARISC_EXT";
3851 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3852 case SHT_PARISC_DOC: return "PARISC_DOC";
3853 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3854 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3855 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3856 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3857 default:
3858 break;
3859 }
3860 return NULL;
3861}
3862
3863static const char *
3864get_ia64_section_type_name (unsigned int sh_type)
3865{
3866 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3867 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3868 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3869
3870 switch (sh_type)
3871 {
3872 case SHT_IA_64_EXT: return "IA_64_EXT";
3873 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3874 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3875 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3876 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3877 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3878 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3879 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3880 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3881 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3882 default:
3883 break;
3884 }
3885 return NULL;
3886}
3887
3888static const char *
3889get_x86_64_section_type_name (unsigned int sh_type)
3890{
3891 switch (sh_type)
3892 {
3893 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3894 default:
3895 break;
3896 }
3897 return NULL;
3898}
3899
3900static const char *
3901get_aarch64_section_type_name (unsigned int sh_type)
3902{
3903 switch (sh_type)
3904 {
3905 case SHT_AARCH64_ATTRIBUTES:
3906 return "AARCH64_ATTRIBUTES";
3907 default:
3908 break;
3909 }
3910 return NULL;
3911}
3912
3913static const char *
3914get_arm_section_type_name (unsigned int sh_type)
3915{
3916 switch (sh_type)
3917 {
3918 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3919 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3920 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3921 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3922 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3923 default:
3924 break;
3925 }
3926 return NULL;
3927}
3928
3929static const char *
3930get_tic6x_section_type_name (unsigned int sh_type)
3931{
3932 switch (sh_type)
3933 {
3934 case SHT_C6000_UNWIND:
3935 return "C6000_UNWIND";
3936 case SHT_C6000_PREEMPTMAP:
3937 return "C6000_PREEMPTMAP";
3938 case SHT_C6000_ATTRIBUTES:
3939 return "C6000_ATTRIBUTES";
3940 case SHT_TI_ICODE:
3941 return "TI_ICODE";
3942 case SHT_TI_XREF:
3943 return "TI_XREF";
3944 case SHT_TI_HANDLER:
3945 return "TI_HANDLER";
3946 case SHT_TI_INITINFO:
3947 return "TI_INITINFO";
3948 case SHT_TI_PHATTRS:
3949 return "TI_PHATTRS";
3950 default:
3951 break;
3952 }
3953 return NULL;
3954}
3955
3956static const char *
3957get_msp430x_section_type_name (unsigned int sh_type)
3958{
3959 switch (sh_type)
3960 {
3961 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3962 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3963 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3964 default: return NULL;
3965 }
3966}
3967
3968static const char *
3969get_v850_section_type_name (unsigned int sh_type)
3970{
3971 switch (sh_type)
3972 {
3973 case SHT_V850_SCOMMON: return "V850 Small Common";
3974 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3975 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3976 case SHT_RENESAS_IOP: return "RENESAS IOP";
3977 case SHT_RENESAS_INFO: return "RENESAS INFO";
3978 default: return NULL;
3979 }
3980}
3981
3982static const char *
3983get_section_type_name (unsigned int sh_type)
3984{
3985 static char buff[32];
3986 const char * result;
3987
3988 switch (sh_type)
3989 {
3990 case SHT_NULL: return "NULL";
3991 case SHT_PROGBITS: return "PROGBITS";
3992 case SHT_SYMTAB: return "SYMTAB";
3993 case SHT_STRTAB: return "STRTAB";
3994 case SHT_RELA: return "RELA";
3995 case SHT_HASH: return "HASH";
3996 case SHT_DYNAMIC: return "DYNAMIC";
3997 case SHT_NOTE: return "NOTE";
3998 case SHT_NOBITS: return "NOBITS";
3999 case SHT_REL: return "REL";
4000 case SHT_SHLIB: return "SHLIB";
4001 case SHT_DYNSYM: return "DYNSYM";
4002 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4003 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4004 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4005 case SHT_GNU_HASH: return "GNU_HASH";
4006 case SHT_GROUP: return "GROUP";
4007 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
4008 case SHT_GNU_verdef: return "VERDEF";
4009 case SHT_GNU_verneed: return "VERNEED";
4010 case SHT_GNU_versym: return "VERSYM";
4011 case 0x6ffffff0: return "VERSYM";
4012 case 0x6ffffffc: return "VERDEF";
4013 case 0x7ffffffd: return "AUXILIARY";
4014 case 0x7fffffff: return "FILTER";
4015 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4016
4017 default:
4018 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4019 {
4020 switch (elf_header.e_machine)
4021 {
4022 case EM_MIPS:
4023 case EM_MIPS_RS3_LE:
4024 result = get_mips_section_type_name (sh_type);
4025 break;
4026 case EM_PARISC:
4027 result = get_parisc_section_type_name (sh_type);
4028 break;
4029 case EM_IA_64:
4030 result = get_ia64_section_type_name (sh_type);
4031 break;
4032 case EM_X86_64:
4033 case EM_L1OM:
4034 case EM_K1OM:
4035 result = get_x86_64_section_type_name (sh_type);
4036 break;
4037 case EM_AARCH64:
4038 result = get_aarch64_section_type_name (sh_type);
4039 break;
4040 case EM_ARM:
4041 result = get_arm_section_type_name (sh_type);
4042 break;
4043 case EM_TI_C6000:
4044 result = get_tic6x_section_type_name (sh_type);
4045 break;
4046 case EM_MSP430:
4047 result = get_msp430x_section_type_name (sh_type);
4048 break;
4049 case EM_V800:
4050 case EM_V850:
4051 case EM_CYGNUS_V850:
4052 result = get_v850_section_type_name (sh_type);
4053 break;
4054 default:
4055 result = NULL;
4056 break;
4057 }
4058
4059 if (result != NULL)
4060 return result;
4061
4062 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4063 }
4064 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4065 {
4066 switch (elf_header.e_machine)
4067 {
4068 case EM_IA_64:
4069 result = get_ia64_section_type_name (sh_type);
4070 break;
4071 default:
4072 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4073 result = get_solaris_section_type (sh_type);
4074 else
4075 result = NULL;
4076 break;
4077 }
4078
4079 if (result != NULL)
4080 return result;
4081
4082 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4083 }
4084 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4085 {
4086 switch (elf_header.e_machine)
4087 {
4088 case EM_V800:
4089 case EM_V850:
4090 case EM_CYGNUS_V850:
4091 result = get_v850_section_type_name (sh_type);
4092 break;
4093 default:
4094 result = NULL;
4095 break;
4096 }
4097
4098 if (result != NULL)
4099 return result;
4100
4101 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4102 }
4103 else
4104 /* This message is probably going to be displayed in a 15
4105 character wide field, so put the hex value first. */
4106 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4107
4108 return buff;
4109 }
4110}
4111
4112#define OPTION_DEBUG_DUMP 512
4113#define OPTION_DYN_SYMS 513
4114#define OPTION_DWARF_DEPTH 514
4115#define OPTION_DWARF_START 515
4116#define OPTION_DWARF_CHECK 516
4117
4118static struct option options[] =
4119{
4120 {"all", no_argument, 0, 'a'},
4121 {"file-header", no_argument, 0, 'h'},
4122 {"program-headers", no_argument, 0, 'l'},
4123 {"headers", no_argument, 0, 'e'},
4124 {"histogram", no_argument, 0, 'I'},
4125 {"segments", no_argument, 0, 'l'},
4126 {"sections", no_argument, 0, 'S'},
4127 {"section-headers", no_argument, 0, 'S'},
4128 {"section-groups", no_argument, 0, 'g'},
4129 {"section-details", no_argument, 0, 't'},
4130 {"full-section-name",no_argument, 0, 'N'},
4131 {"symbols", no_argument, 0, 's'},
4132 {"syms", no_argument, 0, 's'},
4133 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4134 {"relocs", no_argument, 0, 'r'},
4135 {"notes", no_argument, 0, 'n'},
4136 {"dynamic", no_argument, 0, 'd'},
4137 {"arch-specific", no_argument, 0, 'A'},
4138 {"version-info", no_argument, 0, 'V'},
4139 {"use-dynamic", no_argument, 0, 'D'},
4140 {"unwind", no_argument, 0, 'u'},
4141 {"archive-index", no_argument, 0, 'c'},
4142 {"hex-dump", required_argument, 0, 'x'},
4143 {"relocated-dump", required_argument, 0, 'R'},
4144 {"string-dump", required_argument, 0, 'p'},
4145 {"decompress", no_argument, 0, 'z'},
4146#ifdef SUPPORT_DISASSEMBLY
4147 {"instruction-dump", required_argument, 0, 'i'},
4148#endif
4149 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4150
4151 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4152 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4153 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4154
4155 {"version", no_argument, 0, 'v'},
4156 {"wide", no_argument, 0, 'W'},
4157 {"help", no_argument, 0, 'H'},
4158 {0, no_argument, 0, 0}
4159};
4160
4161static void
4162usage (FILE * stream)
4163{
4164 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4165 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4166 fprintf (stream, _(" Options are:\n\
4167 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4168 -h --file-header Display the ELF file header\n\
4169 -l --program-headers Display the program headers\n\
4170 --segments An alias for --program-headers\n\
4171 -S --section-headers Display the sections' header\n\
4172 --sections An alias for --section-headers\n\
4173 -g --section-groups Display the section groups\n\
4174 -t --section-details Display the section details\n\
4175 -e --headers Equivalent to: -h -l -S\n\
4176 -s --syms Display the symbol table\n\
4177 --symbols An alias for --syms\n\
4178 --dyn-syms Display the dynamic symbol table\n\
4179 -n --notes Display the core notes (if present)\n\
4180 -r --relocs Display the relocations (if present)\n\
4181 -u --unwind Display the unwind info (if present)\n\
4182 -d --dynamic Display the dynamic section (if present)\n\
4183 -V --version-info Display the version sections (if present)\n\
4184 -A --arch-specific Display architecture specific information (if any)\n\
4185 -c --archive-index Display the symbol/file index in an archive\n\
4186 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4187 -x --hex-dump=<number|name>\n\
4188 Dump the contents of section <number|name> as bytes\n\
4189 -p --string-dump=<number|name>\n\
4190 Dump the contents of section <number|name> as strings\n\
4191 -R --relocated-dump=<number|name>\n\
4192 Dump the contents of section <number|name> as relocated bytes\n\
4193 -z --decompress Decompress section before dumping it\n\
4194 -w[lLiaprmfFsoRt] or\n\
4195 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4196 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4197 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4198 =addr,=cu_index]\n\
4199 Display the contents of DWARF2 debug sections\n"));
4200 fprintf (stream, _("\
4201 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4202 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4203 or deeper\n"));
4204#ifdef SUPPORT_DISASSEMBLY
4205 fprintf (stream, _("\
4206 -i --instruction-dump=<number|name>\n\
4207 Disassemble the contents of section <number|name>\n"));
4208#endif
4209 fprintf (stream, _("\
4210 -I --histogram Display histogram of bucket list lengths\n\
4211 -W --wide Allow output width to exceed 80 characters\n\
4212 @<file> Read options from <file>\n\
4213 -H --help Display this information\n\
4214 -v --version Display the version number of readelf\n"));
4215
4216 if (REPORT_BUGS_TO[0] && stream == stdout)
4217 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4218
4219 exit (stream == stdout ? 0 : 1);
4220}
4221
4222/* Record the fact that the user wants the contents of section number
4223 SECTION to be displayed using the method(s) encoded as flags bits
4224 in TYPE. Note, TYPE can be zero if we are creating the array for
4225 the first time. */
4226
4227static void
4228request_dump_bynumber (unsigned int section, dump_type type)
4229{
4230 if (section >= num_dump_sects)
4231 {
4232 dump_type * new_dump_sects;
4233
4234 new_dump_sects = (dump_type *) calloc (section + 1,
4235 sizeof (* dump_sects));
4236
4237 if (new_dump_sects == NULL)
4238 error (_("Out of memory allocating dump request table.\n"));
4239 else
4240 {
4241 /* Copy current flag settings. */
4242 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4243
4244 free (dump_sects);
4245
4246 dump_sects = new_dump_sects;
4247 num_dump_sects = section + 1;
4248 }
4249 }
4250
4251 if (dump_sects)
4252 dump_sects[section] |= type;
4253
4254 return;
4255}
4256
4257/* Request a dump by section name. */
4258
4259static void
4260request_dump_byname (const char * section, dump_type type)
4261{
4262 struct dump_list_entry * new_request;
4263
4264 new_request = (struct dump_list_entry *)
4265 malloc (sizeof (struct dump_list_entry));
4266 if (!new_request)
4267 error (_("Out of memory allocating dump request table.\n"));
4268
4269 new_request->name = strdup (section);
4270 if (!new_request->name)
4271 error (_("Out of memory allocating dump request table.\n"));
4272
4273 new_request->type = type;
4274
4275 new_request->next = dump_sects_byname;
4276 dump_sects_byname = new_request;
4277}
4278
4279static inline void
4280request_dump (dump_type type)
4281{
4282 int section;
4283 char * cp;
4284
4285 do_dump++;
4286 section = strtoul (optarg, & cp, 0);
4287
4288 if (! *cp && section >= 0)
4289 request_dump_bynumber (section, type);
4290 else
4291 request_dump_byname (optarg, type);
4292}
4293
4294
4295static void
4296parse_args (int argc, char ** argv)
4297{
4298 int c;
4299
4300 if (argc < 2)
4301 usage (stderr);
4302
4303 while ((c = getopt_long
4304 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4305 {
4306 switch (c)
4307 {
4308 case 0:
4309 /* Long options. */
4310 break;
4311 case 'H':
4312 usage (stdout);
4313 break;
4314
4315 case 'a':
4316 do_syms++;
4317 do_reloc++;
4318 do_unwind++;
4319 do_dynamic++;
4320 do_header++;
4321 do_sections++;
4322 do_section_groups++;
4323 do_segments++;
4324 do_version++;
4325 do_histogram++;
4326 do_arch++;
4327 do_notes++;
4328 break;
4329 case 'g':
4330 do_section_groups++;
4331 break;
4332 case 't':
4333 case 'N':
4334 do_sections++;
4335 do_section_details++;
4336 break;
4337 case 'e':
4338 do_header++;
4339 do_sections++;
4340 do_segments++;
4341 break;
4342 case 'A':
4343 do_arch++;
4344 break;
4345 case 'D':
4346 do_using_dynamic++;
4347 break;
4348 case 'r':
4349 do_reloc++;
4350 break;
4351 case 'u':
4352 do_unwind++;
4353 break;
4354 case 'h':
4355 do_header++;
4356 break;
4357 case 'l':
4358 do_segments++;
4359 break;
4360 case 's':
4361 do_syms++;
4362 break;
4363 case 'S':
4364 do_sections++;
4365 break;
4366 case 'd':
4367 do_dynamic++;
4368 break;
4369 case 'I':
4370 do_histogram++;
4371 break;
4372 case 'n':
4373 do_notes++;
4374 break;
4375 case 'c':
4376 do_archive_index++;
4377 break;
4378 case 'x':
4379 request_dump (HEX_DUMP);
4380 break;
4381 case 'p':
4382 request_dump (STRING_DUMP);
4383 break;
4384 case 'R':
4385 request_dump (RELOC_DUMP);
4386 break;
4387 case 'z':
4388 decompress_dumps++;
4389 break;
4390 case 'w':
4391 do_dump++;
4392 if (optarg == 0)
4393 {
4394 do_debugging = 1;
4395 dwarf_select_sections_all ();
4396 }
4397 else
4398 {
4399 do_debugging = 0;
4400 dwarf_select_sections_by_letters (optarg);
4401 }
4402 break;
4403 case OPTION_DEBUG_DUMP:
4404 do_dump++;
4405 if (optarg == 0)
4406 do_debugging = 1;
4407 else
4408 {
4409 do_debugging = 0;
4410 dwarf_select_sections_by_names (optarg);
4411 }
4412 break;
4413 case OPTION_DWARF_DEPTH:
4414 {
4415 char *cp;
4416
4417 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4418 }
4419 break;
4420 case OPTION_DWARF_START:
4421 {
4422 char *cp;
4423
4424 dwarf_start_die = strtoul (optarg, & cp, 0);
4425 }
4426 break;
4427 case OPTION_DWARF_CHECK:
4428 dwarf_check = 1;
4429 break;
4430 case OPTION_DYN_SYMS:
4431 do_dyn_syms++;
4432 break;
4433#ifdef SUPPORT_DISASSEMBLY
4434 case 'i':
4435 request_dump (DISASS_DUMP);
4436 break;
4437#endif
4438 case 'v':
4439 print_version (program_name);
4440 break;
4441 case 'V':
4442 do_version++;
4443 break;
4444 case 'W':
4445 do_wide++;
4446 break;
4447 default:
4448 /* xgettext:c-format */
4449 error (_("Invalid option '-%c'\n"), c);
4450 /* Drop through. */
4451 case '?':
4452 usage (stderr);
4453 }
4454 }
4455
4456 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4457 && !do_segments && !do_header && !do_dump && !do_version
4458 && !do_histogram && !do_debugging && !do_arch && !do_notes
4459 && !do_section_groups && !do_archive_index
4460 && !do_dyn_syms)
4461 usage (stderr);
4462}
4463
4464static const char *
4465get_elf_class (unsigned int elf_class)
4466{
4467 static char buff[32];
4468
4469 switch (elf_class)
4470 {
4471 case ELFCLASSNONE: return _("none");
4472 case ELFCLASS32: return "ELF32";
4473 case ELFCLASS64: return "ELF64";
4474 default:
4475 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4476 return buff;
4477 }
4478}
4479
4480static const char *
4481get_data_encoding (unsigned int encoding)
4482{
4483 static char buff[32];
4484
4485 switch (encoding)
4486 {
4487 case ELFDATANONE: return _("none");
4488 case ELFDATA2LSB: return _("2's complement, little endian");
4489 case ELFDATA2MSB: return _("2's complement, big endian");
4490 default:
4491 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4492 return buff;
4493 }
4494}
4495
4496/* Decode the data held in 'elf_header'. */
4497
4498static int
4499process_file_header (void)
4500{
4501 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4502 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4503 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4504 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4505 {
4506 error
4507 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4508 return 0;
4509 }
4510
4511 init_dwarf_regnames (elf_header.e_machine);
4512
4513 if (do_header)
4514 {
4515 int i;
4516
4517 printf (_("ELF Header:\n"));
4518 printf (_(" Magic: "));
4519 for (i = 0; i < EI_NIDENT; i++)
4520 printf ("%2.2x ", elf_header.e_ident[i]);
4521 printf ("\n");
4522 printf (_(" Class: %s\n"),
4523 get_elf_class (elf_header.e_ident[EI_CLASS]));
4524 printf (_(" Data: %s\n"),
4525 get_data_encoding (elf_header.e_ident[EI_DATA]));
4526 printf (_(" Version: %d %s\n"),
4527 elf_header.e_ident[EI_VERSION],
4528 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4529 ? "(current)"
4530 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4531 ? _("<unknown: %lx>")
4532 : "")));
4533 printf (_(" OS/ABI: %s\n"),
4534 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4535 printf (_(" ABI Version: %d\n"),
4536 elf_header.e_ident[EI_ABIVERSION]);
4537 printf (_(" Type: %s\n"),
4538 get_file_type (elf_header.e_type));
4539 printf (_(" Machine: %s\n"),
4540 get_machine_name (elf_header.e_machine));
4541 printf (_(" Version: 0x%lx\n"),
4542 (unsigned long) elf_header.e_version);
4543
4544 printf (_(" Entry point address: "));
4545 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4546 printf (_("\n Start of program headers: "));
4547 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4548 printf (_(" (bytes into file)\n Start of section headers: "));
4549 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4550 printf (_(" (bytes into file)\n"));
4551
4552 printf (_(" Flags: 0x%lx%s\n"),
4553 (unsigned long) elf_header.e_flags,
4554 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4555 printf (_(" Size of this header: %ld (bytes)\n"),
4556 (long) elf_header.e_ehsize);
4557 printf (_(" Size of program headers: %ld (bytes)\n"),
4558 (long) elf_header.e_phentsize);
4559 printf (_(" Number of program headers: %ld"),
4560 (long) elf_header.e_phnum);
4561 if (section_headers != NULL
4562 && elf_header.e_phnum == PN_XNUM
4563 && section_headers[0].sh_info != 0)
4564 printf (" (%ld)", (long) section_headers[0].sh_info);
4565 putc ('\n', stdout);
4566 printf (_(" Size of section headers: %ld (bytes)\n"),
4567 (long) elf_header.e_shentsize);
4568 printf (_(" Number of section headers: %ld"),
4569 (long) elf_header.e_shnum);
4570 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4571 printf (" (%ld)", (long) section_headers[0].sh_size);
4572 putc ('\n', stdout);
4573 printf (_(" Section header string table index: %ld"),
4574 (long) elf_header.e_shstrndx);
4575 if (section_headers != NULL
4576 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4577 printf (" (%u)", section_headers[0].sh_link);
4578 else if (elf_header.e_shstrndx != SHN_UNDEF
4579 && elf_header.e_shstrndx >= elf_header.e_shnum)
4580 printf (_(" <corrupt: out of range>"));
4581 putc ('\n', stdout);
4582 }
4583
4584 if (section_headers != NULL)
4585 {
4586 if (elf_header.e_phnum == PN_XNUM
4587 && section_headers[0].sh_info != 0)
4588 elf_header.e_phnum = section_headers[0].sh_info;
4589 if (elf_header.e_shnum == SHN_UNDEF)
4590 elf_header.e_shnum = section_headers[0].sh_size;
4591 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4592 elf_header.e_shstrndx = section_headers[0].sh_link;
4593 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4594 elf_header.e_shstrndx = SHN_UNDEF;
4595 free (section_headers);
4596 section_headers = NULL;
4597 }
4598
4599 return 1;
4600}
4601
4602static bfd_boolean
4603get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4604{
4605 Elf32_External_Phdr * phdrs;
4606 Elf32_External_Phdr * external;
4607 Elf_Internal_Phdr * internal;
4608 unsigned int i;
4609 unsigned int size = elf_header.e_phentsize;
4610 unsigned int num = elf_header.e_phnum;
4611
4612 /* PR binutils/17531: Cope with unexpected section header sizes. */
4613 if (size == 0 || num == 0)
4614 return FALSE;
4615 if (size < sizeof * phdrs)
4616 {
4617 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4618 return FALSE;
4619 }
4620 if (size > sizeof * phdrs)
4621 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4622
4623 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4624 size, num, _("program headers"));
4625 if (phdrs == NULL)
4626 return FALSE;
4627
4628 for (i = 0, internal = pheaders, external = phdrs;
4629 i < elf_header.e_phnum;
4630 i++, internal++, external++)
4631 {
4632 internal->p_type = BYTE_GET (external->p_type);
4633 internal->p_offset = BYTE_GET (external->p_offset);
4634 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4635 internal->p_paddr = BYTE_GET (external->p_paddr);
4636 internal->p_filesz = BYTE_GET (external->p_filesz);
4637 internal->p_memsz = BYTE_GET (external->p_memsz);
4638 internal->p_flags = BYTE_GET (external->p_flags);
4639 internal->p_align = BYTE_GET (external->p_align);
4640 }
4641
4642 free (phdrs);
4643 return TRUE;
4644}
4645
4646static bfd_boolean
4647get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4648{
4649 Elf64_External_Phdr * phdrs;
4650 Elf64_External_Phdr * external;
4651 Elf_Internal_Phdr * internal;
4652 unsigned int i;
4653 unsigned int size = elf_header.e_phentsize;
4654 unsigned int num = elf_header.e_phnum;
4655
4656 /* PR binutils/17531: Cope with unexpected section header sizes. */
4657 if (size == 0 || num == 0)
4658 return FALSE;
4659 if (size < sizeof * phdrs)
4660 {
4661 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4662 return FALSE;
4663 }
4664 if (size > sizeof * phdrs)
4665 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4666
4667 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4668 size, num, _("program headers"));
4669 if (!phdrs)
4670 return FALSE;
4671
4672 for (i = 0, internal = pheaders, external = phdrs;
4673 i < elf_header.e_phnum;
4674 i++, internal++, external++)
4675 {
4676 internal->p_type = BYTE_GET (external->p_type);
4677 internal->p_flags = BYTE_GET (external->p_flags);
4678 internal->p_offset = BYTE_GET (external->p_offset);
4679 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4680 internal->p_paddr = BYTE_GET (external->p_paddr);
4681 internal->p_filesz = BYTE_GET (external->p_filesz);
4682 internal->p_memsz = BYTE_GET (external->p_memsz);
4683 internal->p_align = BYTE_GET (external->p_align);
4684 }
4685
4686 free (phdrs);
4687 return TRUE;
4688}
4689
4690/* Returns 1 if the program headers were read into `program_headers'. */
4691
4692static int
4693get_program_headers (FILE * file)
4694{
4695 Elf_Internal_Phdr * phdrs;
4696
4697 /* Check cache of prior read. */
4698 if (program_headers != NULL)
4699 return 1;
4700
4701 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4702 sizeof (Elf_Internal_Phdr));
4703
4704 if (phdrs == NULL)
4705 {
4706 error (_("Out of memory reading %u program headers\n"),
4707 elf_header.e_phnum);
4708 return 0;
4709 }
4710
4711 if (is_32bit_elf
4712 ? get_32bit_program_headers (file, phdrs)
4713 : get_64bit_program_headers (file, phdrs))
4714 {
4715 program_headers = phdrs;
4716 return 1;
4717 }
4718
4719 free (phdrs);
4720 return 0;
4721}
4722
4723/* Returns 1 if the program headers were loaded. */
4724
4725static int
4726process_program_headers (FILE * file)
4727{
4728 Elf_Internal_Phdr * segment;
4729 unsigned int i;
4730
4731 if (elf_header.e_phnum == 0)
4732 {
4733 /* PR binutils/12467. */
4734 if (elf_header.e_phoff != 0)
4735 warn (_("possibly corrupt ELF header - it has a non-zero program"
4736 " header offset, but no program headers\n"));
4737 else if (do_segments)
4738 printf (_("\nThere are no program headers in this file.\n"));
4739 return 0;
4740 }
4741
4742 if (do_segments && !do_header)
4743 {
4744 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4745 printf (_("Entry point "));
4746 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4747 printf (_("\nThere are %d program headers, starting at offset "),
4748 elf_header.e_phnum);
4749 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4750 printf ("\n");
4751 }
4752
4753 if (! get_program_headers (file))
4754 return 0;
4755
4756 if (do_segments)
4757 {
4758 if (elf_header.e_phnum > 1)
4759 printf (_("\nProgram Headers:\n"));
4760 else
4761 printf (_("\nProgram Headers:\n"));
4762
4763 if (is_32bit_elf)
4764 printf
4765 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4766 else if (do_wide)
4767 printf
4768 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4769 else
4770 {
4771 printf
4772 (_(" Type Offset VirtAddr PhysAddr\n"));
4773 printf
4774 (_(" FileSiz MemSiz Flags Align\n"));
4775 }
4776 }
4777
4778 dynamic_addr = 0;
4779 dynamic_size = 0;
4780
4781 for (i = 0, segment = program_headers;
4782 i < elf_header.e_phnum;
4783 i++, segment++)
4784 {
4785 if (do_segments)
4786 {
4787 printf (" %-14.14s ", get_segment_type (segment->p_type));
4788
4789 if (is_32bit_elf)
4790 {
4791 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4792 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4793 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4794 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4795 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4796 printf ("%c%c%c ",
4797 (segment->p_flags & PF_R ? 'R' : ' '),
4798 (segment->p_flags & PF_W ? 'W' : ' '),
4799 (segment->p_flags & PF_X ? 'E' : ' '));
4800 printf ("%#lx", (unsigned long) segment->p_align);
4801 }
4802 else if (do_wide)
4803 {
4804 if ((unsigned long) segment->p_offset == segment->p_offset)
4805 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4806 else
4807 {
4808 print_vma (segment->p_offset, FULL_HEX);
4809 putchar (' ');
4810 }
4811
4812 print_vma (segment->p_vaddr, FULL_HEX);
4813 putchar (' ');
4814 print_vma (segment->p_paddr, FULL_HEX);
4815 putchar (' ');
4816
4817 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4818 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4819 else
4820 {
4821 print_vma (segment->p_filesz, FULL_HEX);
4822 putchar (' ');
4823 }
4824
4825 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4826 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4827 else
4828 {
4829 print_vma (segment->p_memsz, FULL_HEX);
4830 }
4831
4832 printf (" %c%c%c ",
4833 (segment->p_flags & PF_R ? 'R' : ' '),
4834 (segment->p_flags & PF_W ? 'W' : ' '),
4835 (segment->p_flags & PF_X ? 'E' : ' '));
4836
4837 if ((unsigned long) segment->p_align == segment->p_align)
4838 printf ("%#lx", (unsigned long) segment->p_align);
4839 else
4840 {
4841 print_vma (segment->p_align, PREFIX_HEX);
4842 }
4843 }
4844 else
4845 {
4846 print_vma (segment->p_offset, FULL_HEX);
4847 putchar (' ');
4848 print_vma (segment->p_vaddr, FULL_HEX);
4849 putchar (' ');
4850 print_vma (segment->p_paddr, FULL_HEX);
4851 printf ("\n ");
4852 print_vma (segment->p_filesz, FULL_HEX);
4853 putchar (' ');
4854 print_vma (segment->p_memsz, FULL_HEX);
4855 printf (" %c%c%c ",
4856 (segment->p_flags & PF_R ? 'R' : ' '),
4857 (segment->p_flags & PF_W ? 'W' : ' '),
4858 (segment->p_flags & PF_X ? 'E' : ' '));
4859 print_vma (segment->p_align, HEX);
4860 }
4861 }
4862
4863 if (do_segments)
4864 putc ('\n', stdout);
4865
4866 switch (segment->p_type)
4867 {
4868 case PT_DYNAMIC:
4869 if (dynamic_addr)
4870 error (_("more than one dynamic segment\n"));
4871
4872 /* By default, assume that the .dynamic section is the first
4873 section in the DYNAMIC segment. */
4874 dynamic_addr = segment->p_offset;
4875 dynamic_size = segment->p_filesz;
4876 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4877 if (dynamic_addr + dynamic_size >= current_file_size)
4878 {
4879 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4880 dynamic_addr = dynamic_size = 0;
4881 }
4882
4883 /* Try to locate the .dynamic section. If there is
4884 a section header table, we can easily locate it. */
4885 if (section_headers != NULL)
4886 {
4887 Elf_Internal_Shdr * sec;
4888
4889 sec = find_section (".dynamic");
4890 if (sec == NULL || sec->sh_size == 0)
4891 {
4892 /* A corresponding .dynamic section is expected, but on
4893 IA-64/OpenVMS it is OK for it to be missing. */
4894 if (!is_ia64_vms ())
4895 error (_("no .dynamic section in the dynamic segment\n"));
4896 break;
4897 }
4898
4899 if (sec->sh_type == SHT_NOBITS)
4900 {
4901 dynamic_size = 0;
4902 break;
4903 }
4904
4905 dynamic_addr = sec->sh_offset;
4906 dynamic_size = sec->sh_size;
4907
4908 if (dynamic_addr < segment->p_offset
4909 || dynamic_addr > segment->p_offset + segment->p_filesz)
4910 warn (_("the .dynamic section is not contained"
4911 " within the dynamic segment\n"));
4912 else if (dynamic_addr > segment->p_offset)
4913 warn (_("the .dynamic section is not the first section"
4914 " in the dynamic segment.\n"));
4915 }
4916 break;
4917
4918 case PT_INTERP:
4919 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4920 SEEK_SET))
4921 error (_("Unable to find program interpreter name\n"));
4922 else
4923 {
4924 char fmt [32];
4925 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4926
4927 if (ret >= (int) sizeof (fmt) || ret < 0)
4928 error (_("Internal error: failed to create format string to display program interpreter\n"));
4929
4930 program_interpreter[0] = 0;
4931 if (fscanf (file, fmt, program_interpreter) <= 0)
4932 error (_("Unable to read program interpreter name\n"));
4933
4934 if (do_segments)
4935 printf (_(" [Requesting program interpreter: %s]\n"),
4936 program_interpreter);
4937 }
4938 break;
4939 }
4940 }
4941
4942 if (do_segments && section_headers != NULL && string_table != NULL)
4943 {
4944 printf (_("\n Section to Segment mapping:\n"));
4945 printf (_(" Segment Sections...\n"));
4946
4947 for (i = 0; i < elf_header.e_phnum; i++)
4948 {
4949 unsigned int j;
4950 Elf_Internal_Shdr * section;
4951
4952 segment = program_headers + i;
4953 section = section_headers + 1;
4954
4955 printf (" %2.2d ", i);
4956
4957 for (j = 1; j < elf_header.e_shnum; j++, section++)
4958 {
4959 if (!ELF_TBSS_SPECIAL (section, segment)
4960 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4961 printf ("%s ", printable_section_name (section));
4962 }
4963
4964 putc ('\n',stdout);
4965 }
4966 }
4967
4968 return 1;
4969}
4970
4971
4972/* Find the file offset corresponding to VMA by using the program headers. */
4973
4974static long
4975offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4976{
4977 Elf_Internal_Phdr * seg;
4978
4979 if (! get_program_headers (file))
4980 {
4981 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4982 return (long) vma;
4983 }
4984
4985 for (seg = program_headers;
4986 seg < program_headers + elf_header.e_phnum;
4987 ++seg)
4988 {
4989 if (seg->p_type != PT_LOAD)
4990 continue;
4991
4992 if (vma >= (seg->p_vaddr & -seg->p_align)
4993 && vma + size <= seg->p_vaddr + seg->p_filesz)
4994 return vma - seg->p_vaddr + seg->p_offset;
4995 }
4996
4997 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4998 (unsigned long) vma);
4999 return (long) vma;
5000}
5001
5002
5003/* Allocate memory and load the sections headers into the global pointer
5004 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5005 generate any error messages if the load fails. */
5006
5007static bfd_boolean
5008get_32bit_section_headers (FILE * file, bfd_boolean probe)
5009{
5010 Elf32_External_Shdr * shdrs;
5011 Elf_Internal_Shdr * internal;
5012 unsigned int i;
5013 unsigned int size = elf_header.e_shentsize;
5014 unsigned int num = probe ? 1 : elf_header.e_shnum;
5015
5016 /* PR binutils/17531: Cope with unexpected section header sizes. */
5017 if (size == 0 || num == 0)
5018 return FALSE;
5019 if (size < sizeof * shdrs)
5020 {
5021 if (! probe)
5022 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5023 return FALSE;
5024 }
5025 if (!probe && size > sizeof * shdrs)
5026 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5027
5028 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5029 size, num,
5030 probe ? NULL : _("section headers"));
5031 if (shdrs == NULL)
5032 return FALSE;
5033
5034 if (section_headers != NULL)
5035 free (section_headers);
5036 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5037 sizeof (Elf_Internal_Shdr));
5038 if (section_headers == NULL)
5039 {
5040 if (!probe)
5041 error (_("Out of memory reading %u section headers\n"), num);
5042 return FALSE;
5043 }
5044
5045 for (i = 0, internal = section_headers;
5046 i < num;
5047 i++, internal++)
5048 {
5049 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5050 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5051 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5052 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5053 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5054 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5055 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5056 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5057 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5058 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5059 if (!probe && internal->sh_link > num)
5060 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5061 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5062 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5063 }
5064
5065 free (shdrs);
5066 return TRUE;
5067}
5068
5069static bfd_boolean
5070get_64bit_section_headers (FILE * file, bfd_boolean probe)
5071{
5072 Elf64_External_Shdr * shdrs;
5073 Elf_Internal_Shdr * internal;
5074 unsigned int i;
5075 unsigned int size = elf_header.e_shentsize;
5076 unsigned int num = probe ? 1 : elf_header.e_shnum;
5077
5078 /* PR binutils/17531: Cope with unexpected section header sizes. */
5079 if (size == 0 || num == 0)
5080 return FALSE;
5081 if (size < sizeof * shdrs)
5082 {
5083 if (! probe)
5084 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5085 return FALSE;
5086 }
5087 if (! probe && size > sizeof * shdrs)
5088 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5089
5090 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5091 size, num,
5092 probe ? NULL : _("section headers"));
5093 if (shdrs == NULL)
5094 return FALSE;
5095
5096 if (section_headers != NULL)
5097 free (section_headers);
5098 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5099 sizeof (Elf_Internal_Shdr));
5100 if (section_headers == NULL)
5101 {
5102 if (! probe)
5103 error (_("Out of memory reading %u section headers\n"), num);
5104 return FALSE;
5105 }
5106
5107 for (i = 0, internal = section_headers;
5108 i < num;
5109 i++, internal++)
5110 {
5111 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5112 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5113 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5114 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5115 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5116 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5117 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5118 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5119 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5120 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5121 if (!probe && internal->sh_link > num)
5122 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5123 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5124 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5125 }
5126
5127 free (shdrs);
5128 return TRUE;
5129}
5130
5131static Elf_Internal_Sym *
5132get_32bit_elf_symbols (FILE * file,
5133 Elf_Internal_Shdr * section,
5134 unsigned long * num_syms_return)
5135{
5136 unsigned long number = 0;
5137 Elf32_External_Sym * esyms = NULL;
5138 Elf_External_Sym_Shndx * shndx = NULL;
5139 Elf_Internal_Sym * isyms = NULL;
5140 Elf_Internal_Sym * psym;
5141 unsigned int j;
5142
5143 if (section->sh_size == 0)
5144 {
5145 if (num_syms_return != NULL)
5146 * num_syms_return = 0;
5147 return NULL;
5148 }
5149
5150 /* Run some sanity checks first. */
5151 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5152 {
5153 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5154 printable_section_name (section), (unsigned long) section->sh_entsize);
5155 goto exit_point;
5156 }
5157
5158 if (section->sh_size > current_file_size)
5159 {
5160 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5161 printable_section_name (section), (unsigned long) section->sh_size);
5162 goto exit_point;
5163 }
5164
5165 number = section->sh_size / section->sh_entsize;
5166
5167 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5168 {
5169 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5170 (unsigned long) section->sh_size,
5171 printable_section_name (section),
5172 (unsigned long) section->sh_entsize);
5173 goto exit_point;
5174 }
5175
5176 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5177 section->sh_size, _("symbols"));
5178 if (esyms == NULL)
5179 goto exit_point;
5180
5181 {
5182 elf_section_list * entry;
5183
5184 shndx = NULL;
5185 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5186 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5187 {
5188 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5189 entry->hdr->sh_offset,
5190 1, entry->hdr->sh_size,
5191 _("symbol table section indicies"));
5192 if (shndx == NULL)
5193 goto exit_point;
5194 /* PR17531: file: heap-buffer-overflow */
5195 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5196 {
5197 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5198 printable_section_name (entry->hdr),
5199 (unsigned long) entry->hdr->sh_size,
5200 (unsigned long) section->sh_size);
5201 goto exit_point;
5202 }
5203 }
5204 }
5205
5206 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5207
5208 if (isyms == NULL)
5209 {
5210 error (_("Out of memory reading %lu symbols\n"),
5211 (unsigned long) number);
5212 goto exit_point;
5213 }
5214
5215 for (j = 0, psym = isyms; j < number; j++, psym++)
5216 {
5217 psym->st_name = BYTE_GET (esyms[j].st_name);
5218 psym->st_value = BYTE_GET (esyms[j].st_value);
5219 psym->st_size = BYTE_GET (esyms[j].st_size);
5220 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5221 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5222 psym->st_shndx
5223 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5224 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5225 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5226 psym->st_info = BYTE_GET (esyms[j].st_info);
5227 psym->st_other = BYTE_GET (esyms[j].st_other);
5228 }
5229
5230 exit_point:
5231 if (shndx != NULL)
5232 free (shndx);
5233 if (esyms != NULL)
5234 free (esyms);
5235
5236 if (num_syms_return != NULL)
5237 * num_syms_return = isyms == NULL ? 0 : number;
5238
5239 return isyms;
5240}
5241
5242static Elf_Internal_Sym *
5243get_64bit_elf_symbols (FILE * file,
5244 Elf_Internal_Shdr * section,
5245 unsigned long * num_syms_return)
5246{
5247 unsigned long number = 0;
5248 Elf64_External_Sym * esyms = NULL;
5249 Elf_External_Sym_Shndx * shndx = NULL;
5250 Elf_Internal_Sym * isyms = NULL;
5251 Elf_Internal_Sym * psym;
5252 unsigned int j;
5253
5254 if (section->sh_size == 0)
5255 {
5256 if (num_syms_return != NULL)
5257 * num_syms_return = 0;
5258 return NULL;
5259 }
5260
5261 /* Run some sanity checks first. */
5262 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5263 {
5264 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5265 printable_section_name (section),
5266 (unsigned long) section->sh_entsize);
5267 goto exit_point;
5268 }
5269
5270 if (section->sh_size > current_file_size)
5271 {
5272 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5273 printable_section_name (section),
5274 (unsigned long) section->sh_size);
5275 goto exit_point;
5276 }
5277
5278 number = section->sh_size / section->sh_entsize;
5279
5280 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5281 {
5282 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5283 (unsigned long) section->sh_size,
5284 printable_section_name (section),
5285 (unsigned long) section->sh_entsize);
5286 goto exit_point;
5287 }
5288
5289 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5290 section->sh_size, _("symbols"));
5291 if (!esyms)
5292 goto exit_point;
5293
5294 {
5295 elf_section_list * entry;
5296
5297 shndx = NULL;
5298 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5299 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5300 {
5301 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5302 entry->hdr->sh_offset,
5303 1, entry->hdr->sh_size,
5304 _("symbol table section indicies"));
5305 if (shndx == NULL)
5306 goto exit_point;
5307 /* PR17531: file: heap-buffer-overflow */
5308 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5309 {
5310 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5311 printable_section_name (entry->hdr),
5312 (unsigned long) entry->hdr->sh_size,
5313 (unsigned long) section->sh_size);
5314 goto exit_point;
5315 }
5316 }
5317 }
5318
5319 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5320
5321 if (isyms == NULL)
5322 {
5323 error (_("Out of memory reading %lu symbols\n"),
5324 (unsigned long) number);
5325 goto exit_point;
5326 }
5327
5328 for (j = 0, psym = isyms; j < number; j++, psym++)
5329 {
5330 psym->st_name = BYTE_GET (esyms[j].st_name);
5331 psym->st_info = BYTE_GET (esyms[j].st_info);
5332 psym->st_other = BYTE_GET (esyms[j].st_other);
5333 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5334
5335 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5336 psym->st_shndx
5337 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5338 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5339 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5340
5341 psym->st_value = BYTE_GET (esyms[j].st_value);
5342 psym->st_size = BYTE_GET (esyms[j].st_size);
5343 }
5344
5345 exit_point:
5346 if (shndx != NULL)
5347 free (shndx);
5348 if (esyms != NULL)
5349 free (esyms);
5350
5351 if (num_syms_return != NULL)
5352 * num_syms_return = isyms == NULL ? 0 : number;
5353
5354 return isyms;
5355}
5356
5357static const char *
5358get_elf_section_flags (bfd_vma sh_flags)
5359{
5360 static char buff[1024];
5361 char * p = buff;
5362 int field_size = is_32bit_elf ? 8 : 16;
5363 int sindex;
5364 int size = sizeof (buff) - (field_size + 4 + 1);
5365 bfd_vma os_flags = 0;
5366 bfd_vma proc_flags = 0;
5367 bfd_vma unknown_flags = 0;
5368 static const struct
5369 {
5370 const char * str;
5371 int len;
5372 }
5373 flags [] =
5374 {
5375 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5376 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5377 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5378 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5379 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5380 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5381 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5382 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5383 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5384 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5385 /* IA-64 specific. */
5386 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5387 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5388 /* IA-64 OpenVMS specific. */
5389 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5390 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5391 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5392 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5393 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5394 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5395 /* Generic. */
5396 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5397 /* SPARC specific. */
5398 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5399 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5400 /* ARM specific. */
5401 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5402 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5403 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5404 };
5405
5406 if (do_section_details)
5407 {
5408 sprintf (buff, "[%*.*lx]: ",
5409 field_size, field_size, (unsigned long) sh_flags);
5410 p += field_size + 4;
5411 }
5412
5413 while (sh_flags)
5414 {
5415 bfd_vma flag;
5416
5417 flag = sh_flags & - sh_flags;
5418 sh_flags &= ~ flag;
5419
5420 if (do_section_details)
5421 {
5422 switch (flag)
5423 {
5424 case SHF_WRITE: sindex = 0; break;
5425 case SHF_ALLOC: sindex = 1; break;
5426 case SHF_EXECINSTR: sindex = 2; break;
5427 case SHF_MERGE: sindex = 3; break;
5428 case SHF_STRINGS: sindex = 4; break;
5429 case SHF_INFO_LINK: sindex = 5; break;
5430 case SHF_LINK_ORDER: sindex = 6; break;
5431 case SHF_OS_NONCONFORMING: sindex = 7; break;
5432 case SHF_GROUP: sindex = 8; break;
5433 case SHF_TLS: sindex = 9; break;
5434 case SHF_EXCLUDE: sindex = 18; break;
5435 case SHF_COMPRESSED: sindex = 20; break;
5436
5437 default:
5438 sindex = -1;
5439 switch (elf_header.e_machine)
5440 {
5441 case EM_IA_64:
5442 if (flag == SHF_IA_64_SHORT)
5443 sindex = 10;
5444 else if (flag == SHF_IA_64_NORECOV)
5445 sindex = 11;
5446#ifdef BFD64
5447 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5448 switch (flag)
5449 {
5450 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5451 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5452 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5453 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5454 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5455 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5456 default: break;
5457 }
5458#endif
5459 break;
5460
5461 case EM_386:
5462 case EM_IAMCU:
5463 case EM_X86_64:
5464 case EM_L1OM:
5465 case EM_K1OM:
5466 case EM_OLD_SPARCV9:
5467 case EM_SPARC32PLUS:
5468 case EM_SPARCV9:
5469 case EM_SPARC:
5470 if (flag == SHF_ORDERED)
5471 sindex = 19;
5472 break;
5473
5474 case EM_ARM:
5475 switch (flag)
5476 {
5477 case SHF_ENTRYSECT: sindex = 21; break;
5478 case SHF_ARM_PURECODE: sindex = 22; break;
5479 case SHF_COMDEF: sindex = 23; break;
5480 default: break;
5481 }
5482 break;
5483
5484 default:
5485 break;
5486 }
5487 }
5488
5489 if (sindex != -1)
5490 {
5491 if (p != buff + field_size + 4)
5492 {
5493 if (size < (10 + 2))
5494 {
5495 warn (_("Internal error: not enough buffer room for section flag info"));
5496 return _("<unknown>");
5497 }
5498 size -= 2;
5499 *p++ = ',';
5500 *p++ = ' ';
5501 }
5502
5503 size -= flags [sindex].len;
5504 p = stpcpy (p, flags [sindex].str);
5505 }
5506 else if (flag & SHF_MASKOS)
5507 os_flags |= flag;
5508 else if (flag & SHF_MASKPROC)
5509 proc_flags |= flag;
5510 else
5511 unknown_flags |= flag;
5512 }
5513 else
5514 {
5515 switch (flag)
5516 {
5517 case SHF_WRITE: *p = 'W'; break;
5518 case SHF_ALLOC: *p = 'A'; break;
5519 case SHF_EXECINSTR: *p = 'X'; break;
5520 case SHF_MERGE: *p = 'M'; break;
5521 case SHF_STRINGS: *p = 'S'; break;
5522 case SHF_INFO_LINK: *p = 'I'; break;
5523 case SHF_LINK_ORDER: *p = 'L'; break;
5524 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5525 case SHF_GROUP: *p = 'G'; break;
5526 case SHF_TLS: *p = 'T'; break;
5527 case SHF_EXCLUDE: *p = 'E'; break;
5528 case SHF_COMPRESSED: *p = 'C'; break;
5529
5530 default:
5531 if ((elf_header.e_machine == EM_X86_64
5532 || elf_header.e_machine == EM_L1OM
5533 || elf_header.e_machine == EM_K1OM)
5534 && flag == SHF_X86_64_LARGE)
5535 *p = 'l';
5536 else if (elf_header.e_machine == EM_ARM
5537 && flag == SHF_ARM_PURECODE)
5538 *p = 'y';
5539 else if (flag & SHF_MASKOS)
5540 {
5541 *p = 'o';
5542 sh_flags &= ~ SHF_MASKOS;
5543 }
5544 else if (flag & SHF_MASKPROC)
5545 {
5546 *p = 'p';
5547 sh_flags &= ~ SHF_MASKPROC;
5548 }
5549 else
5550 *p = 'x';
5551 break;
5552 }
5553 p++;
5554 }
5555 }
5556
5557 if (do_section_details)
5558 {
5559 if (os_flags)
5560 {
5561 size -= 5 + field_size;
5562 if (p != buff + field_size + 4)
5563 {
5564 if (size < (2 + 1))
5565 {
5566 warn (_("Internal error: not enough buffer room for section flag info"));
5567 return _("<unknown>");
5568 }
5569 size -= 2;
5570 *p++ = ',';
5571 *p++ = ' ';
5572 }
5573 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5574 (unsigned long) os_flags);
5575 p += 5 + field_size;
5576 }
5577 if (proc_flags)
5578 {
5579 size -= 7 + field_size;
5580 if (p != buff + field_size + 4)
5581 {
5582 if (size < (2 + 1))
5583 {
5584 warn (_("Internal error: not enough buffer room for section flag info"));
5585 return _("<unknown>");
5586 }
5587 size -= 2;
5588 *p++ = ',';
5589 *p++ = ' ';
5590 }
5591 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5592 (unsigned long) proc_flags);
5593 p += 7 + field_size;
5594 }
5595 if (unknown_flags)
5596 {
5597 size -= 10 + field_size;
5598 if (p != buff + field_size + 4)
5599 {
5600 if (size < (2 + 1))
5601 {
5602 warn (_("Internal error: not enough buffer room for section flag info"));
5603 return _("<unknown>");
5604 }
5605 size -= 2;
5606 *p++ = ',';
5607 *p++ = ' ';
5608 }
5609 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5610 (unsigned long) unknown_flags);
5611 p += 10 + field_size;
5612 }
5613 }
5614
5615 *p = '\0';
5616 return buff;
5617}
5618
5619static unsigned int
5620get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5621{
5622 if (is_32bit_elf)
5623 {
5624 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5625 chdr->ch_type = BYTE_GET (echdr->ch_type);
5626 chdr->ch_size = BYTE_GET (echdr->ch_size);
5627 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5628 return sizeof (*echdr);
5629 }
5630 else
5631 {
5632 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5633 chdr->ch_type = BYTE_GET (echdr->ch_type);
5634 chdr->ch_size = BYTE_GET (echdr->ch_size);
5635 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5636 return sizeof (*echdr);
5637 }
5638}
5639
5640static int
5641process_section_headers (FILE * file)
5642{
5643 Elf_Internal_Shdr * section;
5644 unsigned int i;
5645
5646 section_headers = NULL;
5647
5648 if (elf_header.e_shnum == 0)
5649 {
5650 /* PR binutils/12467. */
5651 if (elf_header.e_shoff != 0)
5652 warn (_("possibly corrupt ELF file header - it has a non-zero"
5653 " section header offset, but no section headers\n"));
5654 else if (do_sections)
5655 printf (_("\nThere are no sections in this file.\n"));
5656
5657 return 1;
5658 }
5659
5660 if (do_sections && !do_header)
5661 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5662 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5663
5664 if (is_32bit_elf)
5665 {
5666 if (! get_32bit_section_headers (file, FALSE))
5667 return 0;
5668 }
5669 else if (! get_64bit_section_headers (file, FALSE))
5670 return 0;
5671
5672 /* Read in the string table, so that we have names to display. */
5673 if (elf_header.e_shstrndx != SHN_UNDEF
5674 && elf_header.e_shstrndx < elf_header.e_shnum)
5675 {
5676 section = section_headers + elf_header.e_shstrndx;
5677
5678 if (section->sh_size != 0)
5679 {
5680 string_table = (char *) get_data (NULL, file, section->sh_offset,
5681 1, section->sh_size,
5682 _("string table"));
5683
5684 string_table_length = string_table != NULL ? section->sh_size : 0;
5685 }
5686 }
5687
5688 /* Scan the sections for the dynamic symbol table
5689 and dynamic string table and debug sections. */
5690 dynamic_symbols = NULL;
5691 dynamic_strings = NULL;
5692 dynamic_syminfo = NULL;
5693 symtab_shndx_list = NULL;
5694
5695 eh_addr_size = is_32bit_elf ? 4 : 8;
5696 switch (elf_header.e_machine)
5697 {
5698 case EM_MIPS:
5699 case EM_MIPS_RS3_LE:
5700 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5701 FDE addresses. However, the ABI also has a semi-official ILP32
5702 variant for which the normal FDE address size rules apply.
5703
5704 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5705 section, where XX is the size of longs in bits. Unfortunately,
5706 earlier compilers provided no way of distinguishing ILP32 objects
5707 from LP64 objects, so if there's any doubt, we should assume that
5708 the official LP64 form is being used. */
5709 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5710 && find_section (".gcc_compiled_long32") == NULL)
5711 eh_addr_size = 8;
5712 break;
5713
5714 case EM_H8_300:
5715 case EM_H8_300H:
5716 switch (elf_header.e_flags & EF_H8_MACH)
5717 {
5718 case E_H8_MACH_H8300:
5719 case E_H8_MACH_H8300HN:
5720 case E_H8_MACH_H8300SN:
5721 case E_H8_MACH_H8300SXN:
5722 eh_addr_size = 2;
5723 break;
5724 case E_H8_MACH_H8300H:
5725 case E_H8_MACH_H8300S:
5726 case E_H8_MACH_H8300SX:
5727 eh_addr_size = 4;
5728 break;
5729 }
5730 break;
5731
5732 case EM_M32C_OLD:
5733 case EM_M32C:
5734 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5735 {
5736 case EF_M32C_CPU_M16C:
5737 eh_addr_size = 2;
5738 break;
5739 }
5740 break;
5741 }
5742
5743#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5744 do \
5745 { \
5746 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5747 if (section->sh_entsize != expected_entsize) \
5748 { \
5749 char buf[40]; \
5750 sprintf_vma (buf, section->sh_entsize); \
5751 /* Note: coded this way so that there is a single string for \
5752 translation. */ \
5753 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5754 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5755 (unsigned) expected_entsize); \
5756 section->sh_entsize = expected_entsize; \
5757 } \
5758 } \
5759 while (0)
5760
5761#define CHECK_ENTSIZE(section, i, type) \
5762 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5763 sizeof (Elf64_External_##type))
5764
5765 for (i = 0, section = section_headers;
5766 i < elf_header.e_shnum;
5767 i++, section++)
5768 {
5769 char * name = SECTION_NAME (section);
5770
5771 if (section->sh_type == SHT_DYNSYM)
5772 {
5773 if (dynamic_symbols != NULL)
5774 {
5775 error (_("File contains multiple dynamic symbol tables\n"));
5776 continue;
5777 }
5778
5779 CHECK_ENTSIZE (section, i, Sym);
5780 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5781 }
5782 else if (section->sh_type == SHT_STRTAB
5783 && streq (name, ".dynstr"))
5784 {
5785 if (dynamic_strings != NULL)
5786 {
5787 error (_("File contains multiple dynamic string tables\n"));
5788 continue;
5789 }
5790
5791 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5792 1, section->sh_size,
5793 _("dynamic strings"));
5794 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5795 }
5796 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5797 {
5798 elf_section_list * entry = xmalloc (sizeof * entry);
5799 entry->hdr = section;
5800 entry->next = symtab_shndx_list;
5801 symtab_shndx_list = entry;
5802 }
5803 else if (section->sh_type == SHT_SYMTAB)
5804 CHECK_ENTSIZE (section, i, Sym);
5805 else if (section->sh_type == SHT_GROUP)
5806 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5807 else if (section->sh_type == SHT_REL)
5808 CHECK_ENTSIZE (section, i, Rel);
5809 else if (section->sh_type == SHT_RELA)
5810 CHECK_ENTSIZE (section, i, Rela);
5811 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5812 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5813 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5814 || do_debug_str || do_debug_loc || do_debug_ranges
5815 || do_debug_addr || do_debug_cu_index)
5816 && (const_strneq (name, ".debug_")
5817 || const_strneq (name, ".zdebug_")))
5818 {
5819 if (name[1] == 'z')
5820 name += sizeof (".zdebug_") - 1;
5821 else
5822 name += sizeof (".debug_") - 1;
5823
5824 if (do_debugging
5825 || (do_debug_info && const_strneq (name, "info"))
5826 || (do_debug_info && const_strneq (name, "types"))
5827 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5828 || (do_debug_lines && strcmp (name, "line") == 0)
5829 || (do_debug_lines && const_strneq (name, "line."))
5830 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5831 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5832 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5833 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5834 || (do_debug_aranges && const_strneq (name, "aranges"))
5835 || (do_debug_ranges && const_strneq (name, "ranges"))
5836 || (do_debug_frames && const_strneq (name, "frame"))
5837 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5838 || (do_debug_macinfo && const_strneq (name, "macro"))
5839 || (do_debug_str && const_strneq (name, "str"))
5840 || (do_debug_loc && const_strneq (name, "loc"))
5841 || (do_debug_addr && const_strneq (name, "addr"))
5842 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5843 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5844 )
5845 request_dump_bynumber (i, DEBUG_DUMP);
5846 }
5847 /* Linkonce section to be combined with .debug_info at link time. */
5848 else if ((do_debugging || do_debug_info)
5849 && const_strneq (name, ".gnu.linkonce.wi."))
5850 request_dump_bynumber (i, DEBUG_DUMP);
5851 else if (do_debug_frames && streq (name, ".eh_frame"))
5852 request_dump_bynumber (i, DEBUG_DUMP);
5853 else if (do_gdb_index && streq (name, ".gdb_index"))
5854 request_dump_bynumber (i, DEBUG_DUMP);
5855 /* Trace sections for Itanium VMS. */
5856 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5857 || do_trace_aranges)
5858 && const_strneq (name, ".trace_"))
5859 {
5860 name += sizeof (".trace_") - 1;
5861
5862 if (do_debugging
5863 || (do_trace_info && streq (name, "info"))
5864 || (do_trace_abbrevs && streq (name, "abbrev"))
5865 || (do_trace_aranges && streq (name, "aranges"))
5866 )
5867 request_dump_bynumber (i, DEBUG_DUMP);
5868 }
5869 }
5870
5871 if (! do_sections)
5872 return 1;
5873
5874 if (elf_header.e_shnum > 1)
5875 printf (_("\nSection Headers:\n"));
5876 else
5877 printf (_("\nSection Header:\n"));
5878
5879 if (is_32bit_elf)
5880 {
5881 if (do_section_details)
5882 {
5883 printf (_(" [Nr] Name\n"));
5884 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5885 }
5886 else
5887 printf
5888 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5889 }
5890 else if (do_wide)
5891 {
5892 if (do_section_details)
5893 {
5894 printf (_(" [Nr] Name\n"));
5895 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5896 }
5897 else
5898 printf
5899 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5900 }
5901 else
5902 {
5903 if (do_section_details)
5904 {
5905 printf (_(" [Nr] Name\n"));
5906 printf (_(" Type Address Offset Link\n"));
5907 printf (_(" Size EntSize Info Align\n"));
5908 }
5909 else
5910 {
5911 printf (_(" [Nr] Name Type Address Offset\n"));
5912 printf (_(" Size EntSize Flags Link Info Align\n"));
5913 }
5914 }
5915
5916 if (do_section_details)
5917 printf (_(" Flags\n"));
5918
5919 for (i = 0, section = section_headers;
5920 i < elf_header.e_shnum;
5921 i++, section++)
5922 {
5923 printf (" [%2u] ", i);
5924 if (do_section_details)
5925 printf ("%s\n ", printable_section_name (section));
5926 else
5927 print_symbol (-17, SECTION_NAME (section));
5928
5929 printf (do_wide ? " %-15s " : " %-15.15s ",
5930 get_section_type_name (section->sh_type));
5931
5932 if (is_32bit_elf)
5933 {
5934 const char * link_too_big = NULL;
5935
5936 print_vma (section->sh_addr, LONG_HEX);
5937
5938 printf ( " %6.6lx %6.6lx %2.2lx",
5939 (unsigned long) section->sh_offset,
5940 (unsigned long) section->sh_size,
5941 (unsigned long) section->sh_entsize);
5942
5943 if (do_section_details)
5944 fputs (" ", stdout);
5945 else
5946 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5947
5948 if (section->sh_link >= elf_header.e_shnum)
5949 {
5950 link_too_big = "";
5951 /* The sh_link value is out of range. Normally this indicates
5952 an error but it can have special values in Solaris binaries. */
5953 switch (elf_header.e_machine)
5954 {
5955 case EM_386:
5956 case EM_IAMCU:
5957 case EM_X86_64:
5958 case EM_L1OM:
5959 case EM_K1OM:
5960 case EM_OLD_SPARCV9:
5961 case EM_SPARC32PLUS:
5962 case EM_SPARCV9:
5963 case EM_SPARC:
5964 if (section->sh_link == (SHN_BEFORE & 0xffff))
5965 link_too_big = "BEFORE";
5966 else if (section->sh_link == (SHN_AFTER & 0xffff))
5967 link_too_big = "AFTER";
5968 break;
5969 default:
5970 break;
5971 }
5972 }
5973
5974 if (do_section_details)
5975 {
5976 if (link_too_big != NULL && * link_too_big)
5977 printf ("<%s> ", link_too_big);
5978 else
5979 printf ("%2u ", section->sh_link);
5980 printf ("%3u %2lu\n", section->sh_info,
5981 (unsigned long) section->sh_addralign);
5982 }
5983 else
5984 printf ("%2u %3u %2lu\n",
5985 section->sh_link,
5986 section->sh_info,
5987 (unsigned long) section->sh_addralign);
5988
5989 if (link_too_big && ! * link_too_big)
5990 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5991 i, section->sh_link);
5992 }
5993 else if (do_wide)
5994 {
5995 print_vma (section->sh_addr, LONG_HEX);
5996
5997 if ((long) section->sh_offset == section->sh_offset)
5998 printf (" %6.6lx", (unsigned long) section->sh_offset);
5999 else
6000 {
6001 putchar (' ');
6002 print_vma (section->sh_offset, LONG_HEX);
6003 }
6004
6005 if ((unsigned long) section->sh_size == section->sh_size)
6006 printf (" %6.6lx", (unsigned long) section->sh_size);
6007 else
6008 {
6009 putchar (' ');
6010 print_vma (section->sh_size, LONG_HEX);
6011 }
6012
6013 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6014 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6015 else
6016 {
6017 putchar (' ');
6018 print_vma (section->sh_entsize, LONG_HEX);
6019 }
6020
6021 if (do_section_details)
6022 fputs (" ", stdout);
6023 else
6024 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6025
6026 printf ("%2u %3u ", section->sh_link, section->sh_info);
6027
6028 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6029 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6030 else
6031 {
6032 print_vma (section->sh_addralign, DEC);
6033 putchar ('\n');
6034 }
6035 }
6036 else if (do_section_details)
6037 {
6038 printf (" %-15.15s ",
6039 get_section_type_name (section->sh_type));
6040 print_vma (section->sh_addr, LONG_HEX);
6041 if ((long) section->sh_offset == section->sh_offset)
6042 printf (" %16.16lx", (unsigned long) section->sh_offset);
6043 else
6044 {
6045 printf (" ");
6046 print_vma (section->sh_offset, LONG_HEX);
6047 }
6048 printf (" %u\n ", section->sh_link);
6049 print_vma (section->sh_size, LONG_HEX);
6050 putchar (' ');
6051 print_vma (section->sh_entsize, LONG_HEX);
6052
6053 printf (" %-16u %lu\n",
6054 section->sh_info,
6055 (unsigned long) section->sh_addralign);
6056 }
6057 else
6058 {
6059 putchar (' ');
6060 print_vma (section->sh_addr, LONG_HEX);
6061 if ((long) section->sh_offset == section->sh_offset)
6062 printf (" %8.8lx", (unsigned long) section->sh_offset);
6063 else
6064 {
6065 printf (" ");
6066 print_vma (section->sh_offset, LONG_HEX);
6067 }
6068 printf ("\n ");
6069 print_vma (section->sh_size, LONG_HEX);
6070 printf (" ");
6071 print_vma (section->sh_entsize, LONG_HEX);
6072
6073 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6074
6075 printf (" %2u %3u %lu\n",
6076 section->sh_link,
6077 section->sh_info,
6078 (unsigned long) section->sh_addralign);
6079 }
6080
6081 if (do_section_details)
6082 {
6083 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6084 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6085 {
6086 /* Minimum section size is 12 bytes for 32-bit compression
6087 header + 12 bytes for compressed data header. */
6088 unsigned char buf[24];
6089 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6090 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6091 sizeof (buf), _("compression header")))
6092 {
6093 Elf_Internal_Chdr chdr;
6094 get_compression_header (&chdr, buf);
6095 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6096 printf (" ZLIB, ");
6097 else
6098 printf (_(" [<unknown>: 0x%x], "),
6099 chdr.ch_type);
6100 print_vma (chdr.ch_size, LONG_HEX);
6101 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6102 }
6103 }
6104 }
6105 }
6106
6107 if (!do_section_details)
6108 {
6109 /* The ordering of the letters shown here matches the ordering of the
6110 corresponding SHF_xxx values, and hence the order in which these
6111 letters will be displayed to the user. */
6112 printf (_("Key to Flags:\n\
6113 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6114 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6115 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6116 if (elf_header.e_machine == EM_X86_64
6117 || elf_header.e_machine == EM_L1OM
6118 || elf_header.e_machine == EM_K1OM)
6119 printf (_("l (large), "));
6120 else if (elf_header.e_machine == EM_ARM)
6121 printf (_("y (purecode), "));
6122 printf ("p (processor specific)\n");
6123 }
6124
6125 return 1;
6126}
6127
6128static const char *
6129get_group_flags (unsigned int flags)
6130{
6131 static char buff[32];
6132 switch (flags)
6133 {
6134 case 0:
6135 return "";
6136
6137 case GRP_COMDAT:
6138 return "COMDAT ";
6139
6140 default:
6141 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
6142 break;
6143 }
6144 return buff;
6145}
6146
6147static int
6148process_section_groups (FILE * file)
6149{
6150 Elf_Internal_Shdr * section;
6151 unsigned int i;
6152 struct group * group;
6153 Elf_Internal_Shdr * symtab_sec;
6154 Elf_Internal_Shdr * strtab_sec;
6155 Elf_Internal_Sym * symtab;
6156 unsigned long num_syms;
6157 char * strtab;
6158 size_t strtab_size;
6159
6160 /* Don't process section groups unless needed. */
6161 if (!do_unwind && !do_section_groups)
6162 return 1;
6163
6164 if (elf_header.e_shnum == 0)
6165 {
6166 if (do_section_groups)
6167 printf (_("\nThere are no sections to group in this file.\n"));
6168
6169 return 1;
6170 }
6171
6172 if (section_headers == NULL)
6173 {
6174 error (_("Section headers are not available!\n"));
6175 /* PR 13622: This can happen with a corrupt ELF header. */
6176 return 0;
6177 }
6178
6179 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6180 sizeof (struct group *));
6181
6182 if (section_headers_groups == NULL)
6183 {
6184 error (_("Out of memory reading %u section group headers\n"),
6185 elf_header.e_shnum);
6186 return 0;
6187 }
6188
6189 /* Scan the sections for the group section. */
6190 group_count = 0;
6191 for (i = 0, section = section_headers;
6192 i < elf_header.e_shnum;
6193 i++, section++)
6194 if (section->sh_type == SHT_GROUP)
6195 group_count++;
6196
6197 if (group_count == 0)
6198 {
6199 if (do_section_groups)
6200 printf (_("\nThere are no section groups in this file.\n"));
6201
6202 return 1;
6203 }
6204
6205 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6206
6207 if (section_groups == NULL)
6208 {
6209 error (_("Out of memory reading %lu groups\n"),
6210 (unsigned long) group_count);
6211 return 0;
6212 }
6213
6214 symtab_sec = NULL;
6215 strtab_sec = NULL;
6216 symtab = NULL;
6217 num_syms = 0;
6218 strtab = NULL;
6219 strtab_size = 0;
6220 for (i = 0, section = section_headers, group = section_groups;
6221 i < elf_header.e_shnum;
6222 i++, section++)
6223 {
6224 if (section->sh_type == SHT_GROUP)
6225 {
6226 const char * name = printable_section_name (section);
6227 const char * group_name;
6228 unsigned char * start;
6229 unsigned char * indices;
6230 unsigned int entry, j, size;
6231 Elf_Internal_Shdr * sec;
6232 Elf_Internal_Sym * sym;
6233
6234 /* Get the symbol table. */
6235 if (section->sh_link >= elf_header.e_shnum
6236 || ((sec = section_headers + section->sh_link)->sh_type
6237 != SHT_SYMTAB))
6238 {
6239 error (_("Bad sh_link in group section `%s'\n"), name);
6240 continue;
6241 }
6242
6243 if (symtab_sec != sec)
6244 {
6245 symtab_sec = sec;
6246 if (symtab)
6247 free (symtab);
6248 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6249 }
6250
6251 if (symtab == NULL)
6252 {
6253 error (_("Corrupt header in group section `%s'\n"), name);
6254 continue;
6255 }
6256
6257 if (section->sh_info >= num_syms)
6258 {
6259 error (_("Bad sh_info in group section `%s'\n"), name);
6260 continue;
6261 }
6262
6263 sym = symtab + section->sh_info;
6264
6265 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6266 {
6267 if (sym->st_shndx == 0
6268 || sym->st_shndx >= elf_header.e_shnum)
6269 {
6270 error (_("Bad sh_info in group section `%s'\n"), name);
6271 continue;
6272 }
6273
6274 group_name = SECTION_NAME (section_headers + sym->st_shndx);
6275 strtab_sec = NULL;
6276 if (strtab)
6277 free (strtab);
6278 strtab = NULL;
6279 strtab_size = 0;
6280 }
6281 else
6282 {
6283 /* Get the string table. */
6284 if (symtab_sec->sh_link >= elf_header.e_shnum)
6285 {
6286 strtab_sec = NULL;
6287 if (strtab)
6288 free (strtab);
6289 strtab = NULL;
6290 strtab_size = 0;
6291 }
6292 else if (strtab_sec
6293 != (sec = section_headers + symtab_sec->sh_link))
6294 {
6295 strtab_sec = sec;
6296 if (strtab)
6297 free (strtab);
6298
6299 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6300 1, strtab_sec->sh_size,
6301 _("string table"));
6302 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6303 }
6304 group_name = sym->st_name < strtab_size
6305 ? strtab + sym->st_name : _("<corrupt>");
6306 }
6307
6308 /* PR 17531: file: loop. */
6309 if (section->sh_entsize > section->sh_size)
6310 {
6311 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6312 printable_section_name (section),
6313 (unsigned long) section->sh_entsize,
6314 (unsigned long) section->sh_size);
6315 break;
6316 }
6317
6318 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6319 1, section->sh_size,
6320 _("section data"));
6321 if (start == NULL)
6322 continue;
6323
6324 indices = start;
6325 size = (section->sh_size / section->sh_entsize) - 1;
6326 entry = byte_get (indices, 4);
6327 indices += 4;
6328
6329 if (do_section_groups)
6330 {
6331 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6332 get_group_flags (entry), i, name, group_name, size);
6333
6334 printf (_(" [Index] Name\n"));
6335 }
6336
6337 group->group_index = i;
6338
6339 for (j = 0; j < size; j++)
6340 {
6341 struct group_list * g;
6342
6343 entry = byte_get (indices, 4);
6344 indices += 4;
6345
6346 if (entry >= elf_header.e_shnum)
6347 {
6348 static unsigned num_group_errors = 0;
6349
6350 if (num_group_errors ++ < 10)
6351 {
6352 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6353 entry, i, elf_header.e_shnum - 1);
6354 if (num_group_errors == 10)
6355 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6356 }
6357 continue;
6358 }
6359
6360 if (section_headers_groups [entry] != NULL)
6361 {
6362 if (entry)
6363 {
6364 static unsigned num_errs = 0;
6365
6366 if (num_errs ++ < 10)
6367 {
6368 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6369 entry, i,
6370 section_headers_groups [entry]->group_index);
6371 if (num_errs == 10)
6372 warn (_("Further error messages about already contained group sections suppressed\n"));
6373 }
6374 continue;
6375 }
6376 else
6377 {
6378 /* Intel C/C++ compiler may put section 0 in a
6379 section group. We just warn it the first time
6380 and ignore it afterwards. */
6381 static int warned = 0;
6382 if (!warned)
6383 {
6384 error (_("section 0 in group section [%5u]\n"),
6385 section_headers_groups [entry]->group_index);
6386 warned++;
6387 }
6388 }
6389 }
6390
6391 section_headers_groups [entry] = group;
6392
6393 if (do_section_groups)
6394 {
6395 sec = section_headers + entry;
6396 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6397 }
6398
6399 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6400 g->section_index = entry;
6401 g->next = group->root;
6402 group->root = g;
6403 }
6404
6405 if (start)
6406 free (start);
6407
6408 group++;
6409 }
6410 }
6411
6412 if (symtab)
6413 free (symtab);
6414 if (strtab)
6415 free (strtab);
6416 return 1;
6417}
6418
6419/* Data used to display dynamic fixups. */
6420
6421struct ia64_vms_dynfixup
6422{
6423 bfd_vma needed_ident; /* Library ident number. */
6424 bfd_vma needed; /* Index in the dstrtab of the library name. */
6425 bfd_vma fixup_needed; /* Index of the library. */
6426 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6427 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6428};
6429
6430/* Data used to display dynamic relocations. */
6431
6432struct ia64_vms_dynimgrela
6433{
6434 bfd_vma img_rela_cnt; /* Number of relocations. */
6435 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6436};
6437
6438/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6439 library). */
6440
6441static void
6442dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6443 const char *strtab, unsigned int strtab_sz)
6444{
6445 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6446 long i;
6447 const char *lib_name;
6448
6449 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6450 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6451 _("dynamic section image fixups"));
6452 if (!imfs)
6453 return;
6454
6455 if (fixup->needed < strtab_sz)
6456 lib_name = strtab + fixup->needed;
6457 else
6458 {
6459 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6460 (unsigned long) fixup->needed);
6461 lib_name = "???";
6462 }
6463 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6464 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6465 printf
6466 (_("Seg Offset Type SymVec DataType\n"));
6467
6468 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6469 {
6470 unsigned int type;
6471 const char *rtype;
6472
6473 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6474 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6475 type = BYTE_GET (imfs [i].type);
6476 rtype = elf_ia64_reloc_type (type);
6477 if (rtype == NULL)
6478 printf (" 0x%08x ", type);
6479 else
6480 printf (" %-32s ", rtype);
6481 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6482 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6483 }
6484
6485 free (imfs);
6486}
6487
6488/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6489
6490static void
6491dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6492{
6493 Elf64_External_VMS_IMAGE_RELA *imrs;
6494 long i;
6495
6496 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6497 1, imgrela->img_rela_cnt * sizeof (*imrs),
6498 _("dynamic section image relocations"));
6499 if (!imrs)
6500 return;
6501
6502 printf (_("\nImage relocs\n"));
6503 printf
6504 (_("Seg Offset Type Addend Seg Sym Off\n"));
6505
6506 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6507 {
6508 unsigned int type;
6509 const char *rtype;
6510
6511 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6512 printf ("%08" BFD_VMA_FMT "x ",
6513 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6514 type = BYTE_GET (imrs [i].type);
6515 rtype = elf_ia64_reloc_type (type);
6516 if (rtype == NULL)
6517 printf ("0x%08x ", type);
6518 else
6519 printf ("%-31s ", rtype);
6520 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6521 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6522 printf ("%08" BFD_VMA_FMT "x\n",
6523 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6524 }
6525
6526 free (imrs);
6527}
6528
6529/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6530
6531static int
6532process_ia64_vms_dynamic_relocs (FILE *file)
6533{
6534 struct ia64_vms_dynfixup fixup;
6535 struct ia64_vms_dynimgrela imgrela;
6536 Elf_Internal_Dyn *entry;
6537 int res = 0;
6538 bfd_vma strtab_off = 0;
6539 bfd_vma strtab_sz = 0;
6540 char *strtab = NULL;
6541
6542 memset (&fixup, 0, sizeof (fixup));
6543 memset (&imgrela, 0, sizeof (imgrela));
6544
6545 /* Note: the order of the entries is specified by the OpenVMS specs. */
6546 for (entry = dynamic_section;
6547 entry < dynamic_section + dynamic_nent;
6548 entry++)
6549 {
6550 switch (entry->d_tag)
6551 {
6552 case DT_IA_64_VMS_STRTAB_OFFSET:
6553 strtab_off = entry->d_un.d_val;
6554 break;
6555 case DT_STRSZ:
6556 strtab_sz = entry->d_un.d_val;
6557 if (strtab == NULL)
6558 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6559 1, strtab_sz, _("dynamic string section"));
6560 break;
6561
6562 case DT_IA_64_VMS_NEEDED_IDENT:
6563 fixup.needed_ident = entry->d_un.d_val;
6564 break;
6565 case DT_NEEDED:
6566 fixup.needed = entry->d_un.d_val;
6567 break;
6568 case DT_IA_64_VMS_FIXUP_NEEDED:
6569 fixup.fixup_needed = entry->d_un.d_val;
6570 break;
6571 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6572 fixup.fixup_rela_cnt = entry->d_un.d_val;
6573 break;
6574 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6575 fixup.fixup_rela_off = entry->d_un.d_val;
6576 res++;
6577 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6578 break;
6579
6580 case DT_IA_64_VMS_IMG_RELA_CNT:
6581 imgrela.img_rela_cnt = entry->d_un.d_val;
6582 break;
6583 case DT_IA_64_VMS_IMG_RELA_OFF:
6584 imgrela.img_rela_off = entry->d_un.d_val;
6585 res++;
6586 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6587 break;
6588
6589 default:
6590 break;
6591 }
6592 }
6593
6594 if (strtab != NULL)
6595 free (strtab);
6596
6597 return res;
6598}
6599
6600static struct
6601{
6602 const char * name;
6603 int reloc;
6604 int size;
6605 int rela;
6606} dynamic_relocations [] =
6607{
6608 { "REL", DT_REL, DT_RELSZ, FALSE },
6609 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6610 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6611};
6612
6613/* Process the reloc section. */
6614
6615static int
6616process_relocs (FILE * file)
6617{
6618 unsigned long rel_size;
6619 unsigned long rel_offset;
6620
6621
6622 if (!do_reloc)
6623 return 1;
6624
6625 if (do_using_dynamic)
6626 {
6627 int is_rela;
6628 const char * name;
6629 int has_dynamic_reloc;
6630 unsigned int i;
6631
6632 has_dynamic_reloc = 0;
6633
6634 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6635 {
6636 is_rela = dynamic_relocations [i].rela;
6637 name = dynamic_relocations [i].name;
6638 rel_size = dynamic_info [dynamic_relocations [i].size];
6639 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6640
6641 has_dynamic_reloc |= rel_size;
6642
6643 if (is_rela == UNKNOWN)
6644 {
6645 if (dynamic_relocations [i].reloc == DT_JMPREL)
6646 switch (dynamic_info[DT_PLTREL])
6647 {
6648 case DT_REL:
6649 is_rela = FALSE;
6650 break;
6651 case DT_RELA:
6652 is_rela = TRUE;
6653 break;
6654 }
6655 }
6656
6657 if (rel_size)
6658 {
6659 printf
6660 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6661 name, rel_offset, rel_size);
6662
6663 dump_relocations (file,
6664 offset_from_vma (file, rel_offset, rel_size),
6665 rel_size,
6666 dynamic_symbols, num_dynamic_syms,
6667 dynamic_strings, dynamic_strings_length,
6668 is_rela, 1);
6669 }
6670 }
6671
6672 if (is_ia64_vms ())
6673 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6674
6675 if (! has_dynamic_reloc)
6676 printf (_("\nThere are no dynamic relocations in this file.\n"));
6677 }
6678 else
6679 {
6680 Elf_Internal_Shdr * section;
6681 unsigned long i;
6682 int found = 0;
6683
6684 for (i = 0, section = section_headers;
6685 i < elf_header.e_shnum;
6686 i++, section++)
6687 {
6688 if ( section->sh_type != SHT_RELA
6689 && section->sh_type != SHT_REL)
6690 continue;
6691
6692 rel_offset = section->sh_offset;
6693 rel_size = section->sh_size;
6694
6695 if (rel_size)
6696 {
6697 Elf_Internal_Shdr * strsec;
6698 int is_rela;
6699
6700 printf (_("\nRelocation section "));
6701
6702 if (string_table == NULL)
6703 printf ("%d", section->sh_name);
6704 else
6705 printf ("'%s'", printable_section_name (section));
6706
6707 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6708 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6709
6710 is_rela = section->sh_type == SHT_RELA;
6711
6712 if (section->sh_link != 0
6713 && section->sh_link < elf_header.e_shnum)
6714 {
6715 Elf_Internal_Shdr * symsec;
6716 Elf_Internal_Sym * symtab;
6717 unsigned long nsyms;
6718 unsigned long strtablen = 0;
6719 char * strtab = NULL;
6720
6721 symsec = section_headers + section->sh_link;
6722 if (symsec->sh_type != SHT_SYMTAB
6723 && symsec->sh_type != SHT_DYNSYM)
6724 continue;
6725
6726 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6727
6728 if (symtab == NULL)
6729 continue;
6730
6731 if (symsec->sh_link != 0
6732 && symsec->sh_link < elf_header.e_shnum)
6733 {
6734 strsec = section_headers + symsec->sh_link;
6735
6736 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6737 1, strsec->sh_size,
6738 _("string table"));
6739 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6740 }
6741
6742 dump_relocations (file, rel_offset, rel_size,
6743 symtab, nsyms, strtab, strtablen,
6744 is_rela,
6745 symsec->sh_type == SHT_DYNSYM);
6746 if (strtab)
6747 free (strtab);
6748 free (symtab);
6749 }
6750 else
6751 dump_relocations (file, rel_offset, rel_size,
6752 NULL, 0, NULL, 0, is_rela, 0);
6753
6754 found = 1;
6755 }
6756 }
6757
6758 if (! found)
6759 printf (_("\nThere are no relocations in this file.\n"));
6760 }
6761
6762 return 1;
6763}
6764
6765/* An absolute address consists of a section and an offset. If the
6766 section is NULL, the offset itself is the address, otherwise, the
6767 address equals to LOAD_ADDRESS(section) + offset. */
6768
6769struct absaddr
6770{
6771 unsigned short section;
6772 bfd_vma offset;
6773};
6774
6775#define ABSADDR(a) \
6776 ((a).section \
6777 ? section_headers [(a).section].sh_addr + (a).offset \
6778 : (a).offset)
6779
6780/* Find the nearest symbol at or below ADDR. Returns the symbol
6781 name, if found, and the offset from the symbol to ADDR. */
6782
6783static void
6784find_symbol_for_address (Elf_Internal_Sym * symtab,
6785 unsigned long nsyms,
6786 const char * strtab,
6787 unsigned long strtab_size,
6788 struct absaddr addr,
6789 const char ** symname,
6790 bfd_vma * offset)
6791{
6792 bfd_vma dist = 0x100000;
6793 Elf_Internal_Sym * sym;
6794 Elf_Internal_Sym * beg;
6795 Elf_Internal_Sym * end;
6796 Elf_Internal_Sym * best = NULL;
6797
6798 REMOVE_ARCH_BITS (addr.offset);
6799 beg = symtab;
6800 end = symtab + nsyms;
6801
6802 while (beg < end)
6803 {
6804 bfd_vma value;
6805
6806 sym = beg + (end - beg) / 2;
6807
6808 value = sym->st_value;
6809 REMOVE_ARCH_BITS (value);
6810
6811 if (sym->st_name != 0
6812 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6813 && addr.offset >= value
6814 && addr.offset - value < dist)
6815 {
6816 best = sym;
6817 dist = addr.offset - value;
6818 if (!dist)
6819 break;
6820 }
6821
6822 if (addr.offset < value)
6823 end = sym;
6824 else
6825 beg = sym + 1;
6826 }
6827
6828 if (best)
6829 {
6830 *symname = (best->st_name >= strtab_size
6831 ? _("<corrupt>") : strtab + best->st_name);
6832 *offset = dist;
6833 return;
6834 }
6835
6836 *symname = NULL;
6837 *offset = addr.offset;
6838}
6839
6840static int
6841symcmp (const void *p, const void *q)
6842{
6843 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6844 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6845
6846 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6847}
6848
6849/* Process the unwind section. */
6850
6851#include "unwind-ia64.h"
6852
6853struct ia64_unw_table_entry
6854{
6855 struct absaddr start;
6856 struct absaddr end;
6857 struct absaddr info;
6858};
6859
6860struct ia64_unw_aux_info
6861{
6862 struct ia64_unw_table_entry *table; /* Unwind table. */
6863 unsigned long table_len; /* Length of unwind table. */
6864 unsigned char * info; /* Unwind info. */
6865 unsigned long info_size; /* Size of unwind info. */
6866 bfd_vma info_addr; /* Starting address of unwind info. */
6867 bfd_vma seg_base; /* Starting address of segment. */
6868 Elf_Internal_Sym * symtab; /* The symbol table. */
6869 unsigned long nsyms; /* Number of symbols. */
6870 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6871 unsigned long nfuns; /* Number of entries in funtab. */
6872 char * strtab; /* The string table. */
6873 unsigned long strtab_size; /* Size of string table. */
6874};
6875
6876static void
6877dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6878{
6879 struct ia64_unw_table_entry * tp;
6880 unsigned long j, nfuns;
6881 int in_body;
6882
6883 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6884 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6885 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6886 aux->funtab[nfuns++] = aux->symtab[j];
6887 aux->nfuns = nfuns;
6888 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6889
6890 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6891 {
6892 bfd_vma stamp;
6893 bfd_vma offset;
6894 const unsigned char * dp;
6895 const unsigned char * head;
6896 const unsigned char * end;
6897 const char * procname;
6898
6899 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6900 aux->strtab_size, tp->start, &procname, &offset);
6901
6902 fputs ("\n<", stdout);
6903
6904 if (procname)
6905 {
6906 fputs (procname, stdout);
6907
6908 if (offset)
6909 printf ("+%lx", (unsigned long) offset);
6910 }
6911
6912 fputs (">: [", stdout);
6913 print_vma (tp->start.offset, PREFIX_HEX);
6914 fputc ('-', stdout);
6915 print_vma (tp->end.offset, PREFIX_HEX);
6916 printf ("], info at +0x%lx\n",
6917 (unsigned long) (tp->info.offset - aux->seg_base));
6918
6919 /* PR 17531: file: 86232b32. */
6920 if (aux->info == NULL)
6921 continue;
6922
6923 /* PR 17531: file: 0997b4d1. */
6924 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6925 {
6926 warn (_("Invalid offset %lx in table entry %ld\n"),
6927 (long) tp->info.offset, (long) (tp - aux->table));
6928 continue;
6929 }
6930
6931 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6932 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6933
6934 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6935 (unsigned) UNW_VER (stamp),
6936 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6937 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6938 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6939 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6940
6941 if (UNW_VER (stamp) != 1)
6942 {
6943 printf (_("\tUnknown version.\n"));
6944 continue;
6945 }
6946
6947 in_body = 0;
6948 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6949 /* PR 17531: file: 16ceda89. */
6950 if (end > aux->info + aux->info_size)
6951 end = aux->info + aux->info_size;
6952 for (dp = head + 8; dp < end;)
6953 dp = unw_decode (dp, in_body, & in_body, end);
6954 }
6955
6956 free (aux->funtab);
6957}
6958
6959static bfd_boolean
6960slurp_ia64_unwind_table (FILE * file,
6961 struct ia64_unw_aux_info * aux,
6962 Elf_Internal_Shdr * sec)
6963{
6964 unsigned long size, nrelas, i;
6965 Elf_Internal_Phdr * seg;
6966 struct ia64_unw_table_entry * tep;
6967 Elf_Internal_Shdr * relsec;
6968 Elf_Internal_Rela * rela;
6969 Elf_Internal_Rela * rp;
6970 unsigned char * table;
6971 unsigned char * tp;
6972 Elf_Internal_Sym * sym;
6973 const char * relname;
6974
6975 aux->table_len = 0;
6976
6977 /* First, find the starting address of the segment that includes
6978 this section: */
6979
6980 if (elf_header.e_phnum)
6981 {
6982 if (! get_program_headers (file))
6983 return FALSE;
6984
6985 for (seg = program_headers;
6986 seg < program_headers + elf_header.e_phnum;
6987 ++seg)
6988 {
6989 if (seg->p_type != PT_LOAD)
6990 continue;
6991
6992 if (sec->sh_addr >= seg->p_vaddr
6993 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6994 {
6995 aux->seg_base = seg->p_vaddr;
6996 break;
6997 }
6998 }
6999 }
7000
7001 /* Second, build the unwind table from the contents of the unwind section: */
7002 size = sec->sh_size;
7003 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7004 _("unwind table"));
7005 if (!table)
7006 return FALSE;
7007
7008 aux->table_len = size / (3 * eh_addr_size);
7009 aux->table = (struct ia64_unw_table_entry *)
7010 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7011 tep = aux->table;
7012
7013 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7014 {
7015 tep->start.section = SHN_UNDEF;
7016 tep->end.section = SHN_UNDEF;
7017 tep->info.section = SHN_UNDEF;
7018 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7019 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7020 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7021 tep->start.offset += aux->seg_base;
7022 tep->end.offset += aux->seg_base;
7023 tep->info.offset += aux->seg_base;
7024 }
7025 free (table);
7026
7027 /* Third, apply any relocations to the unwind table: */
7028 for (relsec = section_headers;
7029 relsec < section_headers + elf_header.e_shnum;
7030 ++relsec)
7031 {
7032 if (relsec->sh_type != SHT_RELA
7033 || relsec->sh_info >= elf_header.e_shnum
7034 || section_headers + relsec->sh_info != sec)
7035 continue;
7036
7037 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7038 & rela, & nrelas))
7039 {
7040 free (aux->table);
7041 aux->table = NULL;
7042 aux->table_len = 0;
7043 return FALSE;
7044 }
7045
7046 for (rp = rela; rp < rela + nrelas; ++rp)
7047 {
7048 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7049 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7050
7051 /* PR 17531: file: 9fa67536. */
7052 if (relname == NULL)
7053 {
7054 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7055 continue;
7056 }
7057
7058 if (! const_strneq (relname, "R_IA64_SEGREL"))
7059 {
7060 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7061 continue;
7062 }
7063
7064 i = rp->r_offset / (3 * eh_addr_size);
7065
7066 /* PR 17531: file: 5bc8d9bf. */
7067 if (i >= aux->table_len)
7068 {
7069 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7070 continue;
7071 }
7072
7073 switch (rp->r_offset / eh_addr_size % 3)
7074 {
7075 case 0:
7076 aux->table[i].start.section = sym->st_shndx;
7077 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7078 break;
7079 case 1:
7080 aux->table[i].end.section = sym->st_shndx;
7081 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7082 break;
7083 case 2:
7084 aux->table[i].info.section = sym->st_shndx;
7085 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7086 break;
7087 default:
7088 break;
7089 }
7090 }
7091
7092 free (rela);
7093 }
7094
7095 return TRUE;
7096}
7097
7098static void
7099ia64_process_unwind (FILE * file)
7100{
7101 Elf_Internal_Shdr * sec;
7102 Elf_Internal_Shdr * unwsec = NULL;
7103 Elf_Internal_Shdr * strsec;
7104 unsigned long i, unwcount = 0, unwstart = 0;
7105 struct ia64_unw_aux_info aux;
7106
7107 memset (& aux, 0, sizeof (aux));
7108
7109 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7110 {
7111 if (sec->sh_type == SHT_SYMTAB
7112 && sec->sh_link < elf_header.e_shnum)
7113 {
7114 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7115
7116 strsec = section_headers + sec->sh_link;
7117 if (aux.strtab != NULL)
7118 {
7119 error (_("Multiple auxillary string tables encountered\n"));
7120 free (aux.strtab);
7121 }
7122 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7123 1, strsec->sh_size,
7124 _("string table"));
7125 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7126 }
7127 else if (sec->sh_type == SHT_IA_64_UNWIND)
7128 unwcount++;
7129 }
7130
7131 if (!unwcount)
7132 printf (_("\nThere are no unwind sections in this file.\n"));
7133
7134 while (unwcount-- > 0)
7135 {
7136 char * suffix;
7137 size_t len, len2;
7138
7139 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7140 i < elf_header.e_shnum; ++i, ++sec)
7141 if (sec->sh_type == SHT_IA_64_UNWIND)
7142 {
7143 unwsec = sec;
7144 break;
7145 }
7146 /* We have already counted the number of SHT_IA64_UNWIND
7147 sections so the loop above should never fail. */
7148 assert (unwsec != NULL);
7149
7150 unwstart = i + 1;
7151 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7152
7153 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7154 {
7155 /* We need to find which section group it is in. */
7156 struct group_list * g;
7157
7158 if (section_headers_groups == NULL
7159 || section_headers_groups [i] == NULL)
7160 i = elf_header.e_shnum;
7161 else
7162 {
7163 g = section_headers_groups [i]->root;
7164
7165 for (; g != NULL; g = g->next)
7166 {
7167 sec = section_headers + g->section_index;
7168
7169 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7170 break;
7171 }
7172
7173 if (g == NULL)
7174 i = elf_header.e_shnum;
7175 }
7176 }
7177 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7178 {
7179 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7180 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7181 suffix = SECTION_NAME (unwsec) + len;
7182 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7183 ++i, ++sec)
7184 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7185 && streq (SECTION_NAME (sec) + len2, suffix))
7186 break;
7187 }
7188 else
7189 {
7190 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7191 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7192 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7193 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7194 suffix = "";
7195 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7196 suffix = SECTION_NAME (unwsec) + len;
7197 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7198 ++i, ++sec)
7199 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7200 && streq (SECTION_NAME (sec) + len2, suffix))
7201 break;
7202 }
7203
7204 if (i == elf_header.e_shnum)
7205 {
7206 printf (_("\nCould not find unwind info section for "));
7207
7208 if (string_table == NULL)
7209 printf ("%d", unwsec->sh_name);
7210 else
7211 printf ("'%s'", printable_section_name (unwsec));
7212 }
7213 else
7214 {
7215 aux.info_addr = sec->sh_addr;
7216 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7217 sec->sh_size,
7218 _("unwind info"));
7219 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7220
7221 printf (_("\nUnwind section "));
7222
7223 if (string_table == NULL)
7224 printf ("%d", unwsec->sh_name);
7225 else
7226 printf ("'%s'", printable_section_name (unwsec));
7227
7228 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7229 (unsigned long) unwsec->sh_offset,
7230 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7231
7232 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7233 && aux.table_len > 0)
7234 dump_ia64_unwind (& aux);
7235
7236 if (aux.table)
7237 free ((char *) aux.table);
7238 if (aux.info)
7239 free ((char *) aux.info);
7240 aux.table = NULL;
7241 aux.info = NULL;
7242 }
7243 }
7244
7245 if (aux.symtab)
7246 free (aux.symtab);
7247 if (aux.strtab)
7248 free ((char *) aux.strtab);
7249}
7250
7251struct hppa_unw_table_entry
7252 {
7253 struct absaddr start;
7254 struct absaddr end;
7255 unsigned int Cannot_unwind:1; /* 0 */
7256 unsigned int Millicode:1; /* 1 */
7257 unsigned int Millicode_save_sr0:1; /* 2 */
7258 unsigned int Region_description:2; /* 3..4 */
7259 unsigned int reserved1:1; /* 5 */
7260 unsigned int Entry_SR:1; /* 6 */
7261 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7262 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7263 unsigned int Args_stored:1; /* 16 */
7264 unsigned int Variable_Frame:1; /* 17 */
7265 unsigned int Separate_Package_Body:1; /* 18 */
7266 unsigned int Frame_Extension_Millicode:1; /* 19 */
7267 unsigned int Stack_Overflow_Check:1; /* 20 */
7268 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7269 unsigned int Ada_Region:1; /* 22 */
7270 unsigned int cxx_info:1; /* 23 */
7271 unsigned int cxx_try_catch:1; /* 24 */
7272 unsigned int sched_entry_seq:1; /* 25 */
7273 unsigned int reserved2:1; /* 26 */
7274 unsigned int Save_SP:1; /* 27 */
7275 unsigned int Save_RP:1; /* 28 */
7276 unsigned int Save_MRP_in_frame:1; /* 29 */
7277 unsigned int extn_ptr_defined:1; /* 30 */
7278 unsigned int Cleanup_defined:1; /* 31 */
7279
7280 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7281 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7282 unsigned int Large_frame:1; /* 2 */
7283 unsigned int Pseudo_SP_Set:1; /* 3 */
7284 unsigned int reserved4:1; /* 4 */
7285 unsigned int Total_frame_size:27; /* 5..31 */
7286 };
7287
7288struct hppa_unw_aux_info
7289{
7290 struct hppa_unw_table_entry * table; /* Unwind table. */
7291 unsigned long table_len; /* Length of unwind table. */
7292 bfd_vma seg_base; /* Starting address of segment. */
7293 Elf_Internal_Sym * symtab; /* The symbol table. */
7294 unsigned long nsyms; /* Number of symbols. */
7295 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7296 unsigned long nfuns; /* Number of entries in funtab. */
7297 char * strtab; /* The string table. */
7298 unsigned long strtab_size; /* Size of string table. */
7299};
7300
7301static void
7302dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7303{
7304 struct hppa_unw_table_entry * tp;
7305 unsigned long j, nfuns;
7306
7307 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7308 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7309 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7310 aux->funtab[nfuns++] = aux->symtab[j];
7311 aux->nfuns = nfuns;
7312 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7313
7314 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7315 {
7316 bfd_vma offset;
7317 const char * procname;
7318
7319 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7320 aux->strtab_size, tp->start, &procname,
7321 &offset);
7322
7323 fputs ("\n<", stdout);
7324
7325 if (procname)
7326 {
7327 fputs (procname, stdout);
7328
7329 if (offset)
7330 printf ("+%lx", (unsigned long) offset);
7331 }
7332
7333 fputs (">: [", stdout);
7334 print_vma (tp->start.offset, PREFIX_HEX);
7335 fputc ('-', stdout);
7336 print_vma (tp->end.offset, PREFIX_HEX);
7337 printf ("]\n\t");
7338
7339#define PF(_m) if (tp->_m) printf (#_m " ");
7340#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7341 PF(Cannot_unwind);
7342 PF(Millicode);
7343 PF(Millicode_save_sr0);
7344 /* PV(Region_description); */
7345 PF(Entry_SR);
7346 PV(Entry_FR);
7347 PV(Entry_GR);
7348 PF(Args_stored);
7349 PF(Variable_Frame);
7350 PF(Separate_Package_Body);
7351 PF(Frame_Extension_Millicode);
7352 PF(Stack_Overflow_Check);
7353 PF(Two_Instruction_SP_Increment);
7354 PF(Ada_Region);
7355 PF(cxx_info);
7356 PF(cxx_try_catch);
7357 PF(sched_entry_seq);
7358 PF(Save_SP);
7359 PF(Save_RP);
7360 PF(Save_MRP_in_frame);
7361 PF(extn_ptr_defined);
7362 PF(Cleanup_defined);
7363 PF(MPE_XL_interrupt_marker);
7364 PF(HP_UX_interrupt_marker);
7365 PF(Large_frame);
7366 PF(Pseudo_SP_Set);
7367 PV(Total_frame_size);
7368#undef PF
7369#undef PV
7370 }
7371
7372 printf ("\n");
7373
7374 free (aux->funtab);
7375}
7376
7377static int
7378slurp_hppa_unwind_table (FILE * file,
7379 struct hppa_unw_aux_info * aux,
7380 Elf_Internal_Shdr * sec)
7381{
7382 unsigned long size, unw_ent_size, nentries, nrelas, i;
7383 Elf_Internal_Phdr * seg;
7384 struct hppa_unw_table_entry * tep;
7385 Elf_Internal_Shdr * relsec;
7386 Elf_Internal_Rela * rela;
7387 Elf_Internal_Rela * rp;
7388 unsigned char * table;
7389 unsigned char * tp;
7390 Elf_Internal_Sym * sym;
7391 const char * relname;
7392
7393 /* First, find the starting address of the segment that includes
7394 this section. */
7395
7396 if (elf_header.e_phnum)
7397 {
7398 if (! get_program_headers (file))
7399 return 0;
7400
7401 for (seg = program_headers;
7402 seg < program_headers + elf_header.e_phnum;
7403 ++seg)
7404 {
7405 if (seg->p_type != PT_LOAD)
7406 continue;
7407
7408 if (sec->sh_addr >= seg->p_vaddr
7409 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7410 {
7411 aux->seg_base = seg->p_vaddr;
7412 break;
7413 }
7414 }
7415 }
7416
7417 /* Second, build the unwind table from the contents of the unwind
7418 section. */
7419 size = sec->sh_size;
7420 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7421 _("unwind table"));
7422 if (!table)
7423 return 0;
7424
7425 unw_ent_size = 16;
7426 nentries = size / unw_ent_size;
7427 size = unw_ent_size * nentries;
7428
7429 tep = aux->table = (struct hppa_unw_table_entry *)
7430 xcmalloc (nentries, sizeof (aux->table[0]));
7431
7432 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7433 {
7434 unsigned int tmp1, tmp2;
7435
7436 tep->start.section = SHN_UNDEF;
7437 tep->end.section = SHN_UNDEF;
7438
7439 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7440 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7441 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7442 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7443
7444 tep->start.offset += aux->seg_base;
7445 tep->end.offset += aux->seg_base;
7446
7447 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7448 tep->Millicode = (tmp1 >> 30) & 0x1;
7449 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7450 tep->Region_description = (tmp1 >> 27) & 0x3;
7451 tep->reserved1 = (tmp1 >> 26) & 0x1;
7452 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7453 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7454 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7455 tep->Args_stored = (tmp1 >> 15) & 0x1;
7456 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7457 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7458 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7459 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7460 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7461 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7462 tep->cxx_info = (tmp1 >> 8) & 0x1;
7463 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7464 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7465 tep->reserved2 = (tmp1 >> 5) & 0x1;
7466 tep->Save_SP = (tmp1 >> 4) & 0x1;
7467 tep->Save_RP = (tmp1 >> 3) & 0x1;
7468 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7469 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7470 tep->Cleanup_defined = tmp1 & 0x1;
7471
7472 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7473 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7474 tep->Large_frame = (tmp2 >> 29) & 0x1;
7475 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7476 tep->reserved4 = (tmp2 >> 27) & 0x1;
7477 tep->Total_frame_size = tmp2 & 0x7ffffff;
7478 }
7479 free (table);
7480
7481 /* Third, apply any relocations to the unwind table. */
7482 for (relsec = section_headers;
7483 relsec < section_headers + elf_header.e_shnum;
7484 ++relsec)
7485 {
7486 if (relsec->sh_type != SHT_RELA
7487 || relsec->sh_info >= elf_header.e_shnum
7488 || section_headers + relsec->sh_info != sec)
7489 continue;
7490
7491 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7492 & rela, & nrelas))
7493 return 0;
7494
7495 for (rp = rela; rp < rela + nrelas; ++rp)
7496 {
7497 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7498 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7499
7500 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7501 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7502 {
7503 warn (_("Skipping unexpected relocation type %s\n"), relname);
7504 continue;
7505 }
7506
7507 i = rp->r_offset / unw_ent_size;
7508
7509 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7510 {
7511 case 0:
7512 aux->table[i].start.section = sym->st_shndx;
7513 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7514 break;
7515 case 1:
7516 aux->table[i].end.section = sym->st_shndx;
7517 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7518 break;
7519 default:
7520 break;
7521 }
7522 }
7523
7524 free (rela);
7525 }
7526
7527 aux->table_len = nentries;
7528
7529 return 1;
7530}
7531
7532static void
7533hppa_process_unwind (FILE * file)
7534{
7535 struct hppa_unw_aux_info aux;
7536 Elf_Internal_Shdr * unwsec = NULL;
7537 Elf_Internal_Shdr * strsec;
7538 Elf_Internal_Shdr * sec;
7539 unsigned long i;
7540
7541 if (string_table == NULL)
7542 return;
7543
7544 memset (& aux, 0, sizeof (aux));
7545
7546 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7547 {
7548 if (sec->sh_type == SHT_SYMTAB
7549 && sec->sh_link < elf_header.e_shnum)
7550 {
7551 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7552
7553 strsec = section_headers + sec->sh_link;
7554 if (aux.strtab != NULL)
7555 {
7556 error (_("Multiple auxillary string tables encountered\n"));
7557 free (aux.strtab);
7558 }
7559 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7560 1, strsec->sh_size,
7561 _("string table"));
7562 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7563 }
7564 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7565 unwsec = sec;
7566 }
7567
7568 if (!unwsec)
7569 printf (_("\nThere are no unwind sections in this file.\n"));
7570
7571 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7572 {
7573 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7574 {
7575 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7576 printable_section_name (sec),
7577 (unsigned long) sec->sh_offset,
7578 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7579
7580 slurp_hppa_unwind_table (file, &aux, sec);
7581 if (aux.table_len > 0)
7582 dump_hppa_unwind (&aux);
7583
7584 if (aux.table)
7585 free ((char *) aux.table);
7586 aux.table = NULL;
7587 }
7588 }
7589
7590 if (aux.symtab)
7591 free (aux.symtab);
7592 if (aux.strtab)
7593 free ((char *) aux.strtab);
7594}
7595
7596struct arm_section
7597{
7598 unsigned char * data; /* The unwind data. */
7599 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7600 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7601 unsigned long nrelas; /* The number of relocations. */
7602 unsigned int rel_type; /* REL or RELA ? */
7603 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7604};
7605
7606struct arm_unw_aux_info
7607{
7608 FILE * file; /* The file containing the unwind sections. */
7609 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7610 unsigned long nsyms; /* Number of symbols. */
7611 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7612 unsigned long nfuns; /* Number of these symbols. */
7613 char * strtab; /* The file's string table. */
7614 unsigned long strtab_size; /* Size of string table. */
7615};
7616
7617static const char *
7618arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7619 bfd_vma fn, struct absaddr addr)
7620{
7621 const char *procname;
7622 bfd_vma sym_offset;
7623
7624 if (addr.section == SHN_UNDEF)
7625 addr.offset = fn;
7626
7627 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7628 aux->strtab_size, addr, &procname,
7629 &sym_offset);
7630
7631 print_vma (fn, PREFIX_HEX);
7632
7633 if (procname)
7634 {
7635 fputs (" <", stdout);
7636 fputs (procname, stdout);
7637
7638 if (sym_offset)
7639 printf ("+0x%lx", (unsigned long) sym_offset);
7640 fputc ('>', stdout);
7641 }
7642
7643 return procname;
7644}
7645
7646static void
7647arm_free_section (struct arm_section *arm_sec)
7648{
7649 if (arm_sec->data != NULL)
7650 free (arm_sec->data);
7651
7652 if (arm_sec->rela != NULL)
7653 free (arm_sec->rela);
7654}
7655
7656/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7657 cached section and install SEC instead.
7658 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7659 and return its valued in * WORDP, relocating if necessary.
7660 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7661 relocation's offset in ADDR.
7662 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7663 into the string table of the symbol associated with the reloc. If no
7664 reloc was applied store -1 there.
7665 5) Return TRUE upon success, FALSE otherwise. */
7666
7667static bfd_boolean
7668get_unwind_section_word (struct arm_unw_aux_info * aux,
7669 struct arm_section * arm_sec,
7670 Elf_Internal_Shdr * sec,
7671 bfd_vma word_offset,
7672 unsigned int * wordp,
7673 struct absaddr * addr,
7674 bfd_vma * sym_name)
7675{
7676 Elf_Internal_Rela *rp;
7677 Elf_Internal_Sym *sym;
7678 const char * relname;
7679 unsigned int word;
7680 bfd_boolean wrapped;
7681
7682 if (sec == NULL || arm_sec == NULL)
7683 return FALSE;
7684
7685 addr->section = SHN_UNDEF;
7686 addr->offset = 0;
7687
7688 if (sym_name != NULL)
7689 *sym_name = (bfd_vma) -1;
7690
7691 /* If necessary, update the section cache. */
7692 if (sec != arm_sec->sec)
7693 {
7694 Elf_Internal_Shdr *relsec;
7695
7696 arm_free_section (arm_sec);
7697
7698 arm_sec->sec = sec;
7699 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7700 sec->sh_size, _("unwind data"));
7701 arm_sec->rela = NULL;
7702 arm_sec->nrelas = 0;
7703
7704 for (relsec = section_headers;
7705 relsec < section_headers + elf_header.e_shnum;
7706 ++relsec)
7707 {
7708 if (relsec->sh_info >= elf_header.e_shnum
7709 || section_headers + relsec->sh_info != sec
7710 /* PR 15745: Check the section type as well. */
7711 || (relsec->sh_type != SHT_REL
7712 && relsec->sh_type != SHT_RELA))
7713 continue;
7714
7715 arm_sec->rel_type = relsec->sh_type;
7716 if (relsec->sh_type == SHT_REL)
7717 {
7718 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7719 relsec->sh_size,
7720 & arm_sec->rela, & arm_sec->nrelas))
7721 return FALSE;
7722 }
7723 else /* relsec->sh_type == SHT_RELA */
7724 {
7725 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7726 relsec->sh_size,
7727 & arm_sec->rela, & arm_sec->nrelas))
7728 return FALSE;
7729 }
7730 break;
7731 }
7732
7733 arm_sec->next_rela = arm_sec->rela;
7734 }
7735
7736 /* If there is no unwind data we can do nothing. */
7737 if (arm_sec->data == NULL)
7738 return FALSE;
7739
7740 /* If the offset is invalid then fail. */
7741 if (word_offset > (sec->sh_size - 4)
7742 /* PR 18879 */
7743 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7744 || ((bfd_signed_vma) word_offset) < 0)
7745 return FALSE;
7746
7747 /* Get the word at the required offset. */
7748 word = byte_get (arm_sec->data + word_offset, 4);
7749
7750 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7751 if (arm_sec->rela == NULL)
7752 {
7753 * wordp = word;
7754 return TRUE;
7755 }
7756
7757 /* Look through the relocs to find the one that applies to the provided offset. */
7758 wrapped = FALSE;
7759 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7760 {
7761 bfd_vma prelval, offset;
7762
7763 if (rp->r_offset > word_offset && !wrapped)
7764 {
7765 rp = arm_sec->rela;
7766 wrapped = TRUE;
7767 }
7768 if (rp->r_offset > word_offset)
7769 break;
7770
7771 if (rp->r_offset & 3)
7772 {
7773 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7774 (unsigned long) rp->r_offset);
7775 continue;
7776 }
7777
7778 if (rp->r_offset < word_offset)
7779 continue;
7780
7781 /* PR 17531: file: 027-161405-0.004 */
7782 if (aux->symtab == NULL)
7783 continue;
7784
7785 if (arm_sec->rel_type == SHT_REL)
7786 {
7787 offset = word & 0x7fffffff;
7788 if (offset & 0x40000000)
7789 offset |= ~ (bfd_vma) 0x7fffffff;
7790 }
7791 else if (arm_sec->rel_type == SHT_RELA)
7792 offset = rp->r_addend;
7793 else
7794 {
7795 error (_("Unknown section relocation type %d encountered\n"),
7796 arm_sec->rel_type);
7797 break;
7798 }
7799
7800 /* PR 17531 file: 027-1241568-0.004. */
7801 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7802 {
7803 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7804 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7805 break;
7806 }
7807
7808 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7809 offset += sym->st_value;
7810 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7811
7812 /* Check that we are processing the expected reloc type. */
7813 if (elf_header.e_machine == EM_ARM)
7814 {
7815 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7816 if (relname == NULL)
7817 {
7818 warn (_("Skipping unknown ARM relocation type: %d\n"),
7819 (int) ELF32_R_TYPE (rp->r_info));
7820 continue;
7821 }
7822
7823 if (streq (relname, "R_ARM_NONE"))
7824 continue;
7825
7826 if (! streq (relname, "R_ARM_PREL31"))
7827 {
7828 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7829 continue;
7830 }
7831 }
7832 else if (elf_header.e_machine == EM_TI_C6000)
7833 {
7834 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7835 if (relname == NULL)
7836 {
7837 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7838 (int) ELF32_R_TYPE (rp->r_info));
7839 continue;
7840 }
7841
7842 if (streq (relname, "R_C6000_NONE"))
7843 continue;
7844
7845 if (! streq (relname, "R_C6000_PREL31"))
7846 {
7847 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7848 continue;
7849 }
7850
7851 prelval >>= 1;
7852 }
7853 else
7854 {
7855 /* This function currently only supports ARM and TI unwinders. */
7856 warn (_("Only TI and ARM unwinders are currently supported\n"));
7857 break;
7858 }
7859
7860 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7861 addr->section = sym->st_shndx;
7862 addr->offset = offset;
7863
7864 if (sym_name)
7865 * sym_name = sym->st_name;
7866 break;
7867 }
7868
7869 *wordp = word;
7870 arm_sec->next_rela = rp;
7871
7872 return TRUE;
7873}
7874
7875static const char *tic6x_unwind_regnames[16] =
7876{
7877 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7878 "A14", "A13", "A12", "A11", "A10",
7879 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7880};
7881
7882static void
7883decode_tic6x_unwind_regmask (unsigned int mask)
7884{
7885 int i;
7886
7887 for (i = 12; mask; mask >>= 1, i--)
7888 {
7889 if (mask & 1)
7890 {
7891 fputs (tic6x_unwind_regnames[i], stdout);
7892 if (mask > 1)
7893 fputs (", ", stdout);
7894 }
7895 }
7896}
7897
7898#define ADVANCE \
7899 if (remaining == 0 && more_words) \
7900 { \
7901 data_offset += 4; \
7902 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7903 data_offset, & word, & addr, NULL)) \
7904 return; \
7905 remaining = 4; \
7906 more_words--; \
7907 } \
7908
7909#define GET_OP(OP) \
7910 ADVANCE; \
7911 if (remaining) \
7912 { \
7913 remaining--; \
7914 (OP) = word >> 24; \
7915 word <<= 8; \
7916 } \
7917 else \
7918 { \
7919 printf (_("[Truncated opcode]\n")); \
7920 return; \
7921 } \
7922 printf ("0x%02x ", OP)
7923
7924static void
7925decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7926 unsigned int word,
7927 unsigned int remaining,
7928 unsigned int more_words,
7929 bfd_vma data_offset,
7930 Elf_Internal_Shdr * data_sec,
7931 struct arm_section * data_arm_sec)
7932{
7933 struct absaddr addr;
7934
7935 /* Decode the unwinding instructions. */
7936 while (1)
7937 {
7938 unsigned int op, op2;
7939
7940 ADVANCE;
7941 if (remaining == 0)
7942 break;
7943 remaining--;
7944 op = word >> 24;
7945 word <<= 8;
7946
7947 printf (" 0x%02x ", op);
7948
7949 if ((op & 0xc0) == 0x00)
7950 {
7951 int offset = ((op & 0x3f) << 2) + 4;
7952
7953 printf (" vsp = vsp + %d", offset);
7954 }
7955 else if ((op & 0xc0) == 0x40)
7956 {
7957 int offset = ((op & 0x3f) << 2) + 4;
7958
7959 printf (" vsp = vsp - %d", offset);
7960 }
7961 else if ((op & 0xf0) == 0x80)
7962 {
7963 GET_OP (op2);
7964 if (op == 0x80 && op2 == 0)
7965 printf (_("Refuse to unwind"));
7966 else
7967 {
7968 unsigned int mask = ((op & 0x0f) << 8) | op2;
7969 int first = 1;
7970 int i;
7971
7972 printf ("pop {");
7973 for (i = 0; i < 12; i++)
7974 if (mask & (1 << i))
7975 {
7976 if (first)
7977 first = 0;
7978 else
7979 printf (", ");
7980 printf ("r%d", 4 + i);
7981 }
7982 printf ("}");
7983 }
7984 }
7985 else if ((op & 0xf0) == 0x90)
7986 {
7987 if (op == 0x9d || op == 0x9f)
7988 printf (_(" [Reserved]"));
7989 else
7990 printf (" vsp = r%d", op & 0x0f);
7991 }
7992 else if ((op & 0xf0) == 0xa0)
7993 {
7994 int end = 4 + (op & 0x07);
7995 int first = 1;
7996 int i;
7997
7998 printf (" pop {");
7999 for (i = 4; i <= end; i++)
8000 {
8001 if (first)
8002 first = 0;
8003 else
8004 printf (", ");
8005 printf ("r%d", i);
8006 }
8007 if (op & 0x08)
8008 {
8009 if (!first)
8010 printf (", ");
8011 printf ("r14");
8012 }
8013 printf ("}");
8014 }
8015 else if (op == 0xb0)
8016 printf (_(" finish"));
8017 else if (op == 0xb1)
8018 {
8019 GET_OP (op2);
8020 if (op2 == 0 || (op2 & 0xf0) != 0)
8021 printf (_("[Spare]"));
8022 else
8023 {
8024 unsigned int mask = op2 & 0x0f;
8025 int first = 1;
8026 int i;
8027
8028 printf ("pop {");
8029 for (i = 0; i < 12; i++)
8030 if (mask & (1 << i))
8031 {
8032 if (first)
8033 first = 0;
8034 else
8035 printf (", ");
8036 printf ("r%d", i);
8037 }
8038 printf ("}");
8039 }
8040 }
8041 else if (op == 0xb2)
8042 {
8043 unsigned char buf[9];
8044 unsigned int i, len;
8045 unsigned long offset;
8046
8047 for (i = 0; i < sizeof (buf); i++)
8048 {
8049 GET_OP (buf[i]);
8050 if ((buf[i] & 0x80) == 0)
8051 break;
8052 }
8053 if (i == sizeof (buf))
8054 printf (_("corrupt change to vsp"));
8055 else
8056 {
8057 offset = read_uleb128 (buf, &len, buf + i + 1);
8058 assert (len == i + 1);
8059 offset = offset * 4 + 0x204;
8060 printf ("vsp = vsp + %ld", offset);
8061 }
8062 }
8063 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8064 {
8065 unsigned int first, last;
8066
8067 GET_OP (op2);
8068 first = op2 >> 4;
8069 last = op2 & 0x0f;
8070 if (op == 0xc8)
8071 first = first + 16;
8072 printf ("pop {D%d", first);
8073 if (last)
8074 printf ("-D%d", first + last);
8075 printf ("}");
8076 }
8077 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8078 {
8079 unsigned int count = op & 0x07;
8080
8081 printf ("pop {D8");
8082 if (count)
8083 printf ("-D%d", 8 + count);
8084 printf ("}");
8085 }
8086 else if (op >= 0xc0 && op <= 0xc5)
8087 {
8088 unsigned int count = op & 0x07;
8089
8090 printf (" pop {wR10");
8091 if (count)
8092 printf ("-wR%d", 10 + count);
8093 printf ("}");
8094 }
8095 else if (op == 0xc6)
8096 {
8097 unsigned int first, last;
8098
8099 GET_OP (op2);
8100 first = op2 >> 4;
8101 last = op2 & 0x0f;
8102 printf ("pop {wR%d", first);
8103 if (last)
8104 printf ("-wR%d", first + last);
8105 printf ("}");
8106 }
8107 else if (op == 0xc7)
8108 {
8109 GET_OP (op2);
8110 if (op2 == 0 || (op2 & 0xf0) != 0)
8111 printf (_("[Spare]"));
8112 else
8113 {
8114 unsigned int mask = op2 & 0x0f;
8115 int first = 1;
8116 int i;
8117
8118 printf ("pop {");
8119 for (i = 0; i < 4; i++)
8120 if (mask & (1 << i))
8121 {
8122 if (first)
8123 first = 0;
8124 else
8125 printf (", ");
8126 printf ("wCGR%d", i);
8127 }
8128 printf ("}");
8129 }
8130 }
8131 else
8132 printf (_(" [unsupported opcode]"));
8133 printf ("\n");
8134 }
8135}
8136
8137static void
8138decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8139 unsigned int word,
8140 unsigned int remaining,
8141 unsigned int more_words,
8142 bfd_vma data_offset,
8143 Elf_Internal_Shdr * data_sec,
8144 struct arm_section * data_arm_sec)
8145{
8146 struct absaddr addr;
8147
8148 /* Decode the unwinding instructions. */
8149 while (1)
8150 {
8151 unsigned int op, op2;
8152
8153 ADVANCE;
8154 if (remaining == 0)
8155 break;
8156 remaining--;
8157 op = word >> 24;
8158 word <<= 8;
8159
8160 printf (" 0x%02x ", op);
8161
8162 if ((op & 0xc0) == 0x00)
8163 {
8164 int offset = ((op & 0x3f) << 3) + 8;
8165 printf (" sp = sp + %d", offset);
8166 }
8167 else if ((op & 0xc0) == 0x80)
8168 {
8169 GET_OP (op2);
8170 if (op == 0x80 && op2 == 0)
8171 printf (_("Refuse to unwind"));
8172 else
8173 {
8174 unsigned int mask = ((op & 0x1f) << 8) | op2;
8175 if (op & 0x20)
8176 printf ("pop compact {");
8177 else
8178 printf ("pop {");
8179
8180 decode_tic6x_unwind_regmask (mask);
8181 printf("}");
8182 }
8183 }
8184 else if ((op & 0xf0) == 0xc0)
8185 {
8186 unsigned int reg;
8187 unsigned int nregs;
8188 unsigned int i;
8189 const char *name;
8190 struct
8191 {
8192 unsigned int offset;
8193 unsigned int reg;
8194 } regpos[16];
8195
8196 /* Scan entire instruction first so that GET_OP output is not
8197 interleaved with disassembly. */
8198 nregs = 0;
8199 for (i = 0; nregs < (op & 0xf); i++)
8200 {
8201 GET_OP (op2);
8202 reg = op2 >> 4;
8203 if (reg != 0xf)
8204 {
8205 regpos[nregs].offset = i * 2;
8206 regpos[nregs].reg = reg;
8207 nregs++;
8208 }
8209
8210 reg = op2 & 0xf;
8211 if (reg != 0xf)
8212 {
8213 regpos[nregs].offset = i * 2 + 1;
8214 regpos[nregs].reg = reg;
8215 nregs++;
8216 }
8217 }
8218
8219 printf (_("pop frame {"));
8220 reg = nregs - 1;
8221 for (i = i * 2; i > 0; i--)
8222 {
8223 if (regpos[reg].offset == i - 1)
8224 {
8225 name = tic6x_unwind_regnames[regpos[reg].reg];
8226 if (reg > 0)
8227 reg--;
8228 }
8229 else
8230 name = _("[pad]");
8231
8232 fputs (name, stdout);
8233 if (i > 1)
8234 printf (", ");
8235 }
8236
8237 printf ("}");
8238 }
8239 else if (op == 0xd0)
8240 printf (" MOV FP, SP");
8241 else if (op == 0xd1)
8242 printf (" __c6xabi_pop_rts");
8243 else if (op == 0xd2)
8244 {
8245 unsigned char buf[9];
8246 unsigned int i, len;
8247 unsigned long offset;
8248
8249 for (i = 0; i < sizeof (buf); i++)
8250 {
8251 GET_OP (buf[i]);
8252 if ((buf[i] & 0x80) == 0)
8253 break;
8254 }
8255 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8256 if (i == sizeof (buf))
8257 {
8258 printf ("<corrupt sp adjust>\n");
8259 warn (_("Corrupt stack pointer adjustment detected\n"));
8260 return;
8261 }
8262
8263 offset = read_uleb128 (buf, &len, buf + i + 1);
8264 assert (len == i + 1);
8265 offset = offset * 8 + 0x408;
8266 printf (_("sp = sp + %ld"), offset);
8267 }
8268 else if ((op & 0xf0) == 0xe0)
8269 {
8270 if ((op & 0x0f) == 7)
8271 printf (" RETURN");
8272 else
8273 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8274 }
8275 else
8276 {
8277 printf (_(" [unsupported opcode]"));
8278 }
8279 putchar ('\n');
8280 }
8281}
8282
8283static bfd_vma
8284arm_expand_prel31 (bfd_vma word, bfd_vma where)
8285{
8286 bfd_vma offset;
8287
8288 offset = word & 0x7fffffff;
8289 if (offset & 0x40000000)
8290 offset |= ~ (bfd_vma) 0x7fffffff;
8291
8292 if (elf_header.e_machine == EM_TI_C6000)
8293 offset <<= 1;
8294
8295 return offset + where;
8296}
8297
8298static void
8299decode_arm_unwind (struct arm_unw_aux_info * aux,
8300 unsigned int word,
8301 unsigned int remaining,
8302 bfd_vma data_offset,
8303 Elf_Internal_Shdr * data_sec,
8304 struct arm_section * data_arm_sec)
8305{
8306 int per_index;
8307 unsigned int more_words = 0;
8308 struct absaddr addr;
8309 bfd_vma sym_name = (bfd_vma) -1;
8310
8311 if (remaining == 0)
8312 {
8313 /* Fetch the first word.
8314 Note - when decoding an object file the address extracted
8315 here will always be 0. So we also pass in the sym_name
8316 parameter so that we can find the symbol associated with
8317 the personality routine. */
8318 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8319 & word, & addr, & sym_name))
8320 return;
8321
8322 remaining = 4;
8323 }
8324
8325 if ((word & 0x80000000) == 0)
8326 {
8327 /* Expand prel31 for personality routine. */
8328 bfd_vma fn;
8329 const char *procname;
8330
8331 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8332 printf (_(" Personality routine: "));
8333 if (fn == 0
8334 && addr.section == SHN_UNDEF && addr.offset == 0
8335 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8336 {
8337 procname = aux->strtab + sym_name;
8338 print_vma (fn, PREFIX_HEX);
8339 if (procname)
8340 {
8341 fputs (" <", stdout);
8342 fputs (procname, stdout);
8343 fputc ('>', stdout);
8344 }
8345 }
8346 else
8347 procname = arm_print_vma_and_name (aux, fn, addr);
8348 fputc ('\n', stdout);
8349
8350 /* The GCC personality routines use the standard compact
8351 encoding, starting with one byte giving the number of
8352 words. */
8353 if (procname != NULL
8354 && (const_strneq (procname, "__gcc_personality_v0")
8355 || const_strneq (procname, "__gxx_personality_v0")
8356 || const_strneq (procname, "__gcj_personality_v0")
8357 || const_strneq (procname, "__gnu_objc_personality_v0")))
8358 {
8359 remaining = 0;
8360 more_words = 1;
8361 ADVANCE;
8362 if (!remaining)
8363 {
8364 printf (_(" [Truncated data]\n"));
8365 return;
8366 }
8367 more_words = word >> 24;
8368 word <<= 8;
8369 remaining--;
8370 per_index = -1;
8371 }
8372 else
8373 return;
8374 }
8375 else
8376 {
8377 /* ARM EHABI Section 6.3:
8378
8379 An exception-handling table entry for the compact model looks like:
8380
8381 31 30-28 27-24 23-0
8382 -- ----- ----- ----
8383 1 0 index Data for personalityRoutine[index] */
8384
8385 if (elf_header.e_machine == EM_ARM
8386 && (word & 0x70000000))
8387 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8388
8389 per_index = (word >> 24) & 0x7f;
8390 printf (_(" Compact model index: %d\n"), per_index);
8391 if (per_index == 0)
8392 {
8393 more_words = 0;
8394 word <<= 8;
8395 remaining--;
8396 }
8397 else if (per_index < 3)
8398 {
8399 more_words = (word >> 16) & 0xff;
8400 word <<= 16;
8401 remaining -= 2;
8402 }
8403 }
8404
8405 switch (elf_header.e_machine)
8406 {
8407 case EM_ARM:
8408 if (per_index < 3)
8409 {
8410 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8411 data_offset, data_sec, data_arm_sec);
8412 }
8413 else
8414 {
8415 warn (_("Unknown ARM compact model index encountered\n"));
8416 printf (_(" [reserved]\n"));
8417 }
8418 break;
8419
8420 case EM_TI_C6000:
8421 if (per_index < 3)
8422 {
8423 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8424 data_offset, data_sec, data_arm_sec);
8425 }
8426 else if (per_index < 5)
8427 {
8428 if (((word >> 17) & 0x7f) == 0x7f)
8429 printf (_(" Restore stack from frame pointer\n"));
8430 else
8431 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8432 printf (_(" Registers restored: "));
8433 if (per_index == 4)
8434 printf (" (compact) ");
8435 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8436 putchar ('\n');
8437 printf (_(" Return register: %s\n"),
8438 tic6x_unwind_regnames[word & 0xf]);
8439 }
8440 else
8441 printf (_(" [reserved (%d)]\n"), per_index);
8442 break;
8443
8444 default:
8445 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8446 elf_header.e_machine);
8447 }
8448
8449 /* Decode the descriptors. Not implemented. */
8450}
8451
8452static void
8453dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8454{
8455 struct arm_section exidx_arm_sec, extab_arm_sec;
8456 unsigned int i, exidx_len;
8457 unsigned long j, nfuns;
8458
8459 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8460 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8461 exidx_len = exidx_sec->sh_size / 8;
8462
8463 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8464 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8465 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8466 aux->funtab[nfuns++] = aux->symtab[j];
8467 aux->nfuns = nfuns;
8468 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8469
8470 for (i = 0; i < exidx_len; i++)
8471 {
8472 unsigned int exidx_fn, exidx_entry;
8473 struct absaddr fn_addr, entry_addr;
8474 bfd_vma fn;
8475
8476 fputc ('\n', stdout);
8477
8478 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8479 8 * i, & exidx_fn, & fn_addr, NULL)
8480 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8481 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8482 {
8483 free (aux->funtab);
8484 arm_free_section (& exidx_arm_sec);
8485 arm_free_section (& extab_arm_sec);
8486 return;
8487 }
8488
8489 /* ARM EHABI, Section 5:
8490 An index table entry consists of 2 words.
8491 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8492 if (exidx_fn & 0x80000000)
8493 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8494
8495 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8496
8497 arm_print_vma_and_name (aux, fn, fn_addr);
8498 fputs (": ", stdout);
8499
8500 if (exidx_entry == 1)
8501 {
8502 print_vma (exidx_entry, PREFIX_HEX);
8503 fputs (" [cantunwind]\n", stdout);
8504 }
8505 else if (exidx_entry & 0x80000000)
8506 {
8507 print_vma (exidx_entry, PREFIX_HEX);
8508 fputc ('\n', stdout);
8509 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8510 }
8511 else
8512 {
8513 bfd_vma table, table_offset = 0;
8514 Elf_Internal_Shdr *table_sec;
8515
8516 fputs ("@", stdout);
8517 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8518 print_vma (table, PREFIX_HEX);
8519 printf ("\n");
8520
8521 /* Locate the matching .ARM.extab. */
8522 if (entry_addr.section != SHN_UNDEF
8523 && entry_addr.section < elf_header.e_shnum)
8524 {
8525 table_sec = section_headers + entry_addr.section;
8526 table_offset = entry_addr.offset;
8527 /* PR 18879 */
8528 if (table_offset > table_sec->sh_size
8529 || ((bfd_signed_vma) table_offset) < 0)
8530 {
8531 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8532 (unsigned long) table_offset,
8533 printable_section_name (table_sec));
8534 continue;
8535 }
8536 }
8537 else
8538 {
8539 table_sec = find_section_by_address (table);
8540 if (table_sec != NULL)
8541 table_offset = table - table_sec->sh_addr;
8542 }
8543 if (table_sec == NULL)
8544 {
8545 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8546 (unsigned long) table);
8547 continue;
8548 }
8549 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8550 &extab_arm_sec);
8551 }
8552 }
8553
8554 printf ("\n");
8555
8556 free (aux->funtab);
8557 arm_free_section (&exidx_arm_sec);
8558 arm_free_section (&extab_arm_sec);
8559}
8560
8561/* Used for both ARM and C6X unwinding tables. */
8562
8563static void
8564arm_process_unwind (FILE *file)
8565{
8566 struct arm_unw_aux_info aux;
8567 Elf_Internal_Shdr *unwsec = NULL;
8568 Elf_Internal_Shdr *strsec;
8569 Elf_Internal_Shdr *sec;
8570 unsigned long i;
8571 unsigned int sec_type;
8572
8573 switch (elf_header.e_machine)
8574 {
8575 case EM_ARM:
8576 sec_type = SHT_ARM_EXIDX;
8577 break;
8578
8579 case EM_TI_C6000:
8580 sec_type = SHT_C6000_UNWIND;
8581 break;
8582
8583 default:
8584 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8585 elf_header.e_machine);
8586 return;
8587 }
8588
8589 if (string_table == NULL)
8590 return;
8591
8592 memset (& aux, 0, sizeof (aux));
8593 aux.file = file;
8594
8595 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8596 {
8597 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8598 {
8599 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8600
8601 strsec = section_headers + sec->sh_link;
8602
8603 /* PR binutils/17531 file: 011-12666-0.004. */
8604 if (aux.strtab != NULL)
8605 {
8606 error (_("Multiple string tables found in file.\n"));
8607 free (aux.strtab);
8608 }
8609 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8610 1, strsec->sh_size, _("string table"));
8611 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8612 }
8613 else if (sec->sh_type == sec_type)
8614 unwsec = sec;
8615 }
8616
8617 if (unwsec == NULL)
8618 printf (_("\nThere are no unwind sections in this file.\n"));
8619 else
8620 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8621 {
8622 if (sec->sh_type == sec_type)
8623 {
8624 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8625 printable_section_name (sec),
8626 (unsigned long) sec->sh_offset,
8627 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8628
8629 dump_arm_unwind (&aux, sec);
8630 }
8631 }
8632
8633 if (aux.symtab)
8634 free (aux.symtab);
8635 if (aux.strtab)
8636 free ((char *) aux.strtab);
8637}
8638
8639static void
8640process_unwind (FILE * file)
8641{
8642 struct unwind_handler
8643 {
8644 int machtype;
8645 void (* handler)(FILE *);
8646 } handlers[] =
8647 {
8648 { EM_ARM, arm_process_unwind },
8649 { EM_IA_64, ia64_process_unwind },
8650 { EM_PARISC, hppa_process_unwind },
8651 { EM_TI_C6000, arm_process_unwind },
8652 { 0, 0 }
8653 };
8654 int i;
8655
8656 if (!do_unwind)
8657 return;
8658
8659 for (i = 0; handlers[i].handler != NULL; i++)
8660 if (elf_header.e_machine == handlers[i].machtype)
8661 {
8662 handlers[i].handler (file);
8663 return;
8664 }
8665
8666 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8667 get_machine_name (elf_header.e_machine));
8668}
8669
8670static void
8671dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8672{
8673 switch (entry->d_tag)
8674 {
8675 case DT_MIPS_FLAGS:
8676 if (entry->d_un.d_val == 0)
8677 printf (_("NONE"));
8678 else
8679 {
8680 static const char * opts[] =
8681 {
8682 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8683 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8684 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8685 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8686 "RLD_ORDER_SAFE"
8687 };
8688 unsigned int cnt;
8689 int first = 1;
8690
8691 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8692 if (entry->d_un.d_val & (1 << cnt))
8693 {
8694 printf ("%s%s", first ? "" : " ", opts[cnt]);
8695 first = 0;
8696 }
8697 }
8698 break;
8699
8700 case DT_MIPS_IVERSION:
8701 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8702 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8703 else
8704 {
8705 char buf[40];
8706 sprintf_vma (buf, entry->d_un.d_ptr);
8707 /* Note: coded this way so that there is a single string for translation. */
8708 printf (_("<corrupt: %s>"), buf);
8709 }
8710 break;
8711
8712 case DT_MIPS_TIME_STAMP:
8713 {
8714 char timebuf[128];
8715 struct tm * tmp;
8716 time_t atime = entry->d_un.d_val;
8717
8718 tmp = gmtime (&atime);
8719 /* PR 17531: file: 6accc532. */
8720 if (tmp == NULL)
8721 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8722 else
8723 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8724 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8725 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8726 printf (_("Time Stamp: %s"), timebuf);
8727 }
8728 break;
8729
8730 case DT_MIPS_RLD_VERSION:
8731 case DT_MIPS_LOCAL_GOTNO:
8732 case DT_MIPS_CONFLICTNO:
8733 case DT_MIPS_LIBLISTNO:
8734 case DT_MIPS_SYMTABNO:
8735 case DT_MIPS_UNREFEXTNO:
8736 case DT_MIPS_HIPAGENO:
8737 case DT_MIPS_DELTA_CLASS_NO:
8738 case DT_MIPS_DELTA_INSTANCE_NO:
8739 case DT_MIPS_DELTA_RELOC_NO:
8740 case DT_MIPS_DELTA_SYM_NO:
8741 case DT_MIPS_DELTA_CLASSSYM_NO:
8742 case DT_MIPS_COMPACT_SIZE:
8743 print_vma (entry->d_un.d_val, DEC);
8744 break;
8745
8746 default:
8747 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8748 }
8749 putchar ('\n');
8750}
8751
8752static void
8753dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8754{
8755 switch (entry->d_tag)
8756 {
8757 case DT_HP_DLD_FLAGS:
8758 {
8759 static struct
8760 {
8761 long int bit;
8762 const char * str;
8763 }
8764 flags[] =
8765 {
8766 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8767 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8768 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8769 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8770 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8771 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8772 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8773 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8774 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8775 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8776 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8777 { DT_HP_GST, "HP_GST" },
8778 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8779 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8780 { DT_HP_NODELETE, "HP_NODELETE" },
8781 { DT_HP_GROUP, "HP_GROUP" },
8782 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8783 };
8784 int first = 1;
8785 size_t cnt;
8786 bfd_vma val = entry->d_un.d_val;
8787
8788 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8789 if (val & flags[cnt].bit)
8790 {
8791 if (! first)
8792 putchar (' ');
8793 fputs (flags[cnt].str, stdout);
8794 first = 0;
8795 val ^= flags[cnt].bit;
8796 }
8797
8798 if (val != 0 || first)
8799 {
8800 if (! first)
8801 putchar (' ');
8802 print_vma (val, HEX);
8803 }
8804 }
8805 break;
8806
8807 default:
8808 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8809 break;
8810 }
8811 putchar ('\n');
8812}
8813
8814#ifdef BFD64
8815
8816/* VMS vs Unix time offset and factor. */
8817
8818#define VMS_EPOCH_OFFSET 35067168000000000LL
8819#define VMS_GRANULARITY_FACTOR 10000000
8820
8821/* Display a VMS time in a human readable format. */
8822
8823static void
8824print_vms_time (bfd_int64_t vmstime)
8825{
8826 struct tm *tm;
8827 time_t unxtime;
8828
8829 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8830 tm = gmtime (&unxtime);
8831 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8832 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8833 tm->tm_hour, tm->tm_min, tm->tm_sec);
8834}
8835#endif /* BFD64 */
8836
8837static void
8838dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8839{
8840 switch (entry->d_tag)
8841 {
8842 case DT_IA_64_PLT_RESERVE:
8843 /* First 3 slots reserved. */
8844 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8845 printf (" -- ");
8846 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8847 break;
8848
8849 case DT_IA_64_VMS_LINKTIME:
8850#ifdef BFD64
8851 print_vms_time (entry->d_un.d_val);
8852#endif
8853 break;
8854
8855 case DT_IA_64_VMS_LNKFLAGS:
8856 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8857 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8858 printf (" CALL_DEBUG");
8859 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8860 printf (" NOP0BUFS");
8861 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8862 printf (" P0IMAGE");
8863 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8864 printf (" MKTHREADS");
8865 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8866 printf (" UPCALLS");
8867 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8868 printf (" IMGSTA");
8869 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8870 printf (" INITIALIZE");
8871 if (entry->d_un.d_val & VMS_LF_MAIN)
8872 printf (" MAIN");
8873 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8874 printf (" EXE_INIT");
8875 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8876 printf (" TBK_IN_IMG");
8877 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8878 printf (" DBG_IN_IMG");
8879 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8880 printf (" TBK_IN_DSF");
8881 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8882 printf (" DBG_IN_DSF");
8883 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8884 printf (" SIGNATURES");
8885 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8886 printf (" REL_SEG_OFF");
8887 break;
8888
8889 default:
8890 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8891 break;
8892 }
8893 putchar ('\n');
8894}
8895
8896static int
8897get_32bit_dynamic_section (FILE * file)
8898{
8899 Elf32_External_Dyn * edyn;
8900 Elf32_External_Dyn * ext;
8901 Elf_Internal_Dyn * entry;
8902
8903 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8904 dynamic_size, _("dynamic section"));
8905 if (!edyn)
8906 return 0;
8907
8908 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8909 might not have the luxury of section headers. Look for the DT_NULL
8910 terminator to determine the number of entries. */
8911 for (ext = edyn, dynamic_nent = 0;
8912 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8913 ext++)
8914 {
8915 dynamic_nent++;
8916 if (BYTE_GET (ext->d_tag) == DT_NULL)
8917 break;
8918 }
8919
8920 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8921 sizeof (* entry));
8922 if (dynamic_section == NULL)
8923 {
8924 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8925 (unsigned long) dynamic_nent);
8926 free (edyn);
8927 return 0;
8928 }
8929
8930 for (ext = edyn, entry = dynamic_section;
8931 entry < dynamic_section + dynamic_nent;
8932 ext++, entry++)
8933 {
8934 entry->d_tag = BYTE_GET (ext->d_tag);
8935 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8936 }
8937
8938 free (edyn);
8939
8940 return 1;
8941}
8942
8943static int
8944get_64bit_dynamic_section (FILE * file)
8945{
8946 Elf64_External_Dyn * edyn;
8947 Elf64_External_Dyn * ext;
8948 Elf_Internal_Dyn * entry;
8949
8950 /* Read in the data. */
8951 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8952 dynamic_size, _("dynamic section"));
8953 if (!edyn)
8954 return 0;
8955
8956 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8957 might not have the luxury of section headers. Look for the DT_NULL
8958 terminator to determine the number of entries. */
8959 for (ext = edyn, dynamic_nent = 0;
8960 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8961 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8962 ext++)
8963 {
8964 dynamic_nent++;
8965 if (BYTE_GET (ext->d_tag) == DT_NULL)
8966 break;
8967 }
8968
8969 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8970 sizeof (* entry));
8971 if (dynamic_section == NULL)
8972 {
8973 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8974 (unsigned long) dynamic_nent);
8975 free (edyn);
8976 return 0;
8977 }
8978
8979 /* Convert from external to internal formats. */
8980 for (ext = edyn, entry = dynamic_section;
8981 entry < dynamic_section + dynamic_nent;
8982 ext++, entry++)
8983 {
8984 entry->d_tag = BYTE_GET (ext->d_tag);
8985 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8986 }
8987
8988 free (edyn);
8989
8990 return 1;
8991}
8992
8993static void
8994print_dynamic_flags (bfd_vma flags)
8995{
8996 int first = 1;
8997
8998 while (flags)
8999 {
9000 bfd_vma flag;
9001
9002 flag = flags & - flags;
9003 flags &= ~ flag;
9004
9005 if (first)
9006 first = 0;
9007 else
9008 putc (' ', stdout);
9009
9010 switch (flag)
9011 {
9012 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9013 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9014 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9015 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9016 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9017 default: fputs (_("unknown"), stdout); break;
9018 }
9019 }
9020 puts ("");
9021}
9022
9023/* Parse and display the contents of the dynamic section. */
9024
9025static int
9026process_dynamic_section (FILE * file)
9027{
9028 Elf_Internal_Dyn * entry;
9029
9030 if (dynamic_size == 0)
9031 {
9032 if (do_dynamic)
9033 printf (_("\nThere is no dynamic section in this file.\n"));
9034
9035 return 1;
9036 }
9037
9038 if (is_32bit_elf)
9039 {
9040 if (! get_32bit_dynamic_section (file))
9041 return 0;
9042 }
9043 else if (! get_64bit_dynamic_section (file))
9044 return 0;
9045
9046 /* Find the appropriate symbol table. */
9047 if (dynamic_symbols == NULL)
9048 {
9049 for (entry = dynamic_section;
9050 entry < dynamic_section + dynamic_nent;
9051 ++entry)
9052 {
9053 Elf_Internal_Shdr section;
9054
9055 if (entry->d_tag != DT_SYMTAB)
9056 continue;
9057
9058 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9059
9060 /* Since we do not know how big the symbol table is,
9061 we default to reading in the entire file (!) and
9062 processing that. This is overkill, I know, but it
9063 should work. */
9064 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9065
9066 if (archive_file_offset != 0)
9067 section.sh_size = archive_file_size - section.sh_offset;
9068 else
9069 {
9070 if (fseek (file, 0, SEEK_END))
9071 error (_("Unable to seek to end of file!\n"));
9072
9073 section.sh_size = ftell (file) - section.sh_offset;
9074 }
9075
9076 if (is_32bit_elf)
9077 section.sh_entsize = sizeof (Elf32_External_Sym);
9078 else
9079 section.sh_entsize = sizeof (Elf64_External_Sym);
9080 section.sh_name = string_table_length;
9081
9082 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9083 if (num_dynamic_syms < 1)
9084 {
9085 error (_("Unable to determine the number of symbols to load\n"));
9086 continue;
9087 }
9088 }
9089 }
9090
9091 /* Similarly find a string table. */
9092 if (dynamic_strings == NULL)
9093 {
9094 for (entry = dynamic_section;
9095 entry < dynamic_section + dynamic_nent;
9096 ++entry)
9097 {
9098 unsigned long offset;
9099 long str_tab_len;
9100
9101 if (entry->d_tag != DT_STRTAB)
9102 continue;
9103
9104 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9105
9106 /* Since we do not know how big the string table is,
9107 we default to reading in the entire file (!) and
9108 processing that. This is overkill, I know, but it
9109 should work. */
9110
9111 offset = offset_from_vma (file, entry->d_un.d_val, 0);
9112
9113 if (archive_file_offset != 0)
9114 str_tab_len = archive_file_size - offset;
9115 else
9116 {
9117 if (fseek (file, 0, SEEK_END))
9118 error (_("Unable to seek to end of file\n"));
9119 str_tab_len = ftell (file) - offset;
9120 }
9121
9122 if (str_tab_len < 1)
9123 {
9124 error
9125 (_("Unable to determine the length of the dynamic string table\n"));
9126 continue;
9127 }
9128
9129 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9130 str_tab_len,
9131 _("dynamic string table"));
9132 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9133 break;
9134 }
9135 }
9136
9137 /* And find the syminfo section if available. */
9138 if (dynamic_syminfo == NULL)
9139 {
9140 unsigned long syminsz = 0;
9141
9142 for (entry = dynamic_section;
9143 entry < dynamic_section + dynamic_nent;
9144 ++entry)
9145 {
9146 if (entry->d_tag == DT_SYMINENT)
9147 {
9148 /* Note: these braces are necessary to avoid a syntax
9149 error from the SunOS4 C compiler. */
9150 /* PR binutils/17531: A corrupt file can trigger this test.
9151 So do not use an assert, instead generate an error message. */
9152 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9153 error (_("Bad value (%d) for SYMINENT entry\n"),
9154 (int) entry->d_un.d_val);
9155 }
9156 else if (entry->d_tag == DT_SYMINSZ)
9157 syminsz = entry->d_un.d_val;
9158 else if (entry->d_tag == DT_SYMINFO)
9159 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9160 syminsz);
9161 }
9162
9163 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9164 {
9165 Elf_External_Syminfo * extsyminfo;
9166 Elf_External_Syminfo * extsym;
9167 Elf_Internal_Syminfo * syminfo;
9168
9169 /* There is a syminfo section. Read the data. */
9170 extsyminfo = (Elf_External_Syminfo *)
9171 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9172 _("symbol information"));
9173 if (!extsyminfo)
9174 return 0;
9175
9176 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9177 if (dynamic_syminfo == NULL)
9178 {
9179 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9180 (unsigned long) syminsz);
9181 return 0;
9182 }
9183
9184 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9185 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9186 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9187 ++syminfo, ++extsym)
9188 {
9189 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9190 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9191 }
9192
9193 free (extsyminfo);
9194 }
9195 }
9196
9197 if (do_dynamic && dynamic_addr)
9198 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9199 dynamic_addr, (unsigned long) dynamic_nent);
9200 if (do_dynamic)
9201 printf (_(" Tag Type Name/Value\n"));
9202
9203 for (entry = dynamic_section;
9204 entry < dynamic_section + dynamic_nent;
9205 entry++)
9206 {
9207 if (do_dynamic)
9208 {
9209 const char * dtype;
9210
9211 putchar (' ');
9212 print_vma (entry->d_tag, FULL_HEX);
9213 dtype = get_dynamic_type (entry->d_tag);
9214 printf (" (%s)%*s", dtype,
9215 ((is_32bit_elf ? 27 : 19)
9216 - (int) strlen (dtype)),
9217 " ");
9218 }
9219
9220 switch (entry->d_tag)
9221 {
9222 case DT_FLAGS:
9223 if (do_dynamic)
9224 print_dynamic_flags (entry->d_un.d_val);
9225 break;
9226
9227 case DT_AUXILIARY:
9228 case DT_FILTER:
9229 case DT_CONFIG:
9230 case DT_DEPAUDIT:
9231 case DT_AUDIT:
9232 if (do_dynamic)
9233 {
9234 switch (entry->d_tag)
9235 {
9236 case DT_AUXILIARY:
9237 printf (_("Auxiliary library"));
9238 break;
9239
9240 case DT_FILTER:
9241 printf (_("Filter library"));
9242 break;
9243
9244 case DT_CONFIG:
9245 printf (_("Configuration file"));
9246 break;
9247
9248 case DT_DEPAUDIT:
9249 printf (_("Dependency audit library"));
9250 break;
9251
9252 case DT_AUDIT:
9253 printf (_("Audit library"));
9254 break;
9255 }
9256
9257 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9258 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9259 else
9260 {
9261 printf (": ");
9262 print_vma (entry->d_un.d_val, PREFIX_HEX);
9263 putchar ('\n');
9264 }
9265 }
9266 break;
9267
9268 case DT_FEATURE:
9269 if (do_dynamic)
9270 {
9271 printf (_("Flags:"));
9272
9273 if (entry->d_un.d_val == 0)
9274 printf (_(" None\n"));
9275 else
9276 {
9277 unsigned long int val = entry->d_un.d_val;
9278
9279 if (val & DTF_1_PARINIT)
9280 {
9281 printf (" PARINIT");
9282 val ^= DTF_1_PARINIT;
9283 }
9284 if (val & DTF_1_CONFEXP)
9285 {
9286 printf (" CONFEXP");
9287 val ^= DTF_1_CONFEXP;
9288 }
9289 if (val != 0)
9290 printf (" %lx", val);
9291 puts ("");
9292 }
9293 }
9294 break;
9295
9296 case DT_POSFLAG_1:
9297 if (do_dynamic)
9298 {
9299 printf (_("Flags:"));
9300
9301 if (entry->d_un.d_val == 0)
9302 printf (_(" None\n"));
9303 else
9304 {
9305 unsigned long int val = entry->d_un.d_val;
9306
9307 if (val & DF_P1_LAZYLOAD)
9308 {
9309 printf (" LAZYLOAD");
9310 val ^= DF_P1_LAZYLOAD;
9311 }
9312 if (val & DF_P1_GROUPPERM)
9313 {
9314 printf (" GROUPPERM");
9315 val ^= DF_P1_GROUPPERM;
9316 }
9317 if (val != 0)
9318 printf (" %lx", val);
9319 puts ("");
9320 }
9321 }
9322 break;
9323
9324 case DT_FLAGS_1:
9325 if (do_dynamic)
9326 {
9327 printf (_("Flags:"));
9328 if (entry->d_un.d_val == 0)
9329 printf (_(" None\n"));
9330 else
9331 {
9332 unsigned long int val = entry->d_un.d_val;
9333
9334 if (val & DF_1_NOW)
9335 {
9336 printf (" NOW");
9337 val ^= DF_1_NOW;
9338 }
9339 if (val & DF_1_GLOBAL)
9340 {
9341 printf (" GLOBAL");
9342 val ^= DF_1_GLOBAL;
9343 }
9344 if (val & DF_1_GROUP)
9345 {
9346 printf (" GROUP");
9347 val ^= DF_1_GROUP;
9348 }
9349 if (val & DF_1_NODELETE)
9350 {
9351 printf (" NODELETE");
9352 val ^= DF_1_NODELETE;
9353 }
9354 if (val & DF_1_LOADFLTR)
9355 {
9356 printf (" LOADFLTR");
9357 val ^= DF_1_LOADFLTR;
9358 }
9359 if (val & DF_1_INITFIRST)
9360 {
9361 printf (" INITFIRST");
9362 val ^= DF_1_INITFIRST;
9363 }
9364 if (val & DF_1_NOOPEN)
9365 {
9366 printf (" NOOPEN");
9367 val ^= DF_1_NOOPEN;
9368 }
9369 if (val & DF_1_ORIGIN)
9370 {
9371 printf (" ORIGIN");
9372 val ^= DF_1_ORIGIN;
9373 }
9374 if (val & DF_1_DIRECT)
9375 {
9376 printf (" DIRECT");
9377 val ^= DF_1_DIRECT;
9378 }
9379 if (val & DF_1_TRANS)
9380 {
9381 printf (" TRANS");
9382 val ^= DF_1_TRANS;
9383 }
9384 if (val & DF_1_INTERPOSE)
9385 {
9386 printf (" INTERPOSE");
9387 val ^= DF_1_INTERPOSE;
9388 }
9389 if (val & DF_1_NODEFLIB)
9390 {
9391 printf (" NODEFLIB");
9392 val ^= DF_1_NODEFLIB;
9393 }
9394 if (val & DF_1_NODUMP)
9395 {
9396 printf (" NODUMP");
9397 val ^= DF_1_NODUMP;
9398 }
9399 if (val & DF_1_CONFALT)
9400 {
9401 printf (" CONFALT");
9402 val ^= DF_1_CONFALT;
9403 }
9404 if (val & DF_1_ENDFILTEE)
9405 {
9406 printf (" ENDFILTEE");
9407 val ^= DF_1_ENDFILTEE;
9408 }
9409 if (val & DF_1_DISPRELDNE)
9410 {
9411 printf (" DISPRELDNE");
9412 val ^= DF_1_DISPRELDNE;
9413 }
9414 if (val & DF_1_DISPRELPND)
9415 {
9416 printf (" DISPRELPND");
9417 val ^= DF_1_DISPRELPND;
9418 }
9419 if (val & DF_1_NODIRECT)
9420 {
9421 printf (" NODIRECT");
9422 val ^= DF_1_NODIRECT;
9423 }
9424 if (val & DF_1_IGNMULDEF)
9425 {
9426 printf (" IGNMULDEF");
9427 val ^= DF_1_IGNMULDEF;
9428 }
9429 if (val & DF_1_NOKSYMS)
9430 {
9431 printf (" NOKSYMS");
9432 val ^= DF_1_NOKSYMS;
9433 }
9434 if (val & DF_1_NOHDR)
9435 {
9436 printf (" NOHDR");
9437 val ^= DF_1_NOHDR;
9438 }
9439 if (val & DF_1_EDITED)
9440 {
9441 printf (" EDITED");
9442 val ^= DF_1_EDITED;
9443 }
9444 if (val & DF_1_NORELOC)
9445 {
9446 printf (" NORELOC");
9447 val ^= DF_1_NORELOC;
9448 }
9449 if (val & DF_1_SYMINTPOSE)
9450 {
9451 printf (" SYMINTPOSE");
9452 val ^= DF_1_SYMINTPOSE;
9453 }
9454 if (val & DF_1_GLOBAUDIT)
9455 {
9456 printf (" GLOBAUDIT");
9457 val ^= DF_1_GLOBAUDIT;
9458 }
9459 if (val & DF_1_SINGLETON)
9460 {
9461 printf (" SINGLETON");
9462 val ^= DF_1_SINGLETON;
9463 }
9464 if (val & DF_1_STUB)
9465 {
9466 printf (" STUB");
9467 val ^= DF_1_STUB;
9468 }
9469 if (val & DF_1_PIE)
9470 {
9471 printf (" PIE");
9472 val ^= DF_1_PIE;
9473 }
9474 if (val != 0)
9475 printf (" %lx", val);
9476 puts ("");
9477 }
9478 }
9479 break;
9480
9481 case DT_PLTREL:
9482 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9483 if (do_dynamic)
9484 puts (get_dynamic_type (entry->d_un.d_val));
9485 break;
9486
9487 case DT_NULL :
9488 case DT_NEEDED :
9489 case DT_PLTGOT :
9490 case DT_HASH :
9491 case DT_STRTAB :
9492 case DT_SYMTAB :
9493 case DT_RELA :
9494 case DT_INIT :
9495 case DT_FINI :
9496 case DT_SONAME :
9497 case DT_RPATH :
9498 case DT_SYMBOLIC:
9499 case DT_REL :
9500 case DT_DEBUG :
9501 case DT_TEXTREL :
9502 case DT_JMPREL :
9503 case DT_RUNPATH :
9504 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9505
9506 if (do_dynamic)
9507 {
9508 char * name;
9509
9510 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9511 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9512 else
9513 name = NULL;
9514
9515 if (name)
9516 {
9517 switch (entry->d_tag)
9518 {
9519 case DT_NEEDED:
9520 printf (_("Shared library: [%s]"), name);
9521
9522 if (streq (name, program_interpreter))
9523 printf (_(" program interpreter"));
9524 break;
9525
9526 case DT_SONAME:
9527 printf (_("Library soname: [%s]"), name);
9528 break;
9529
9530 case DT_RPATH:
9531 printf (_("Library rpath: [%s]"), name);
9532 break;
9533
9534 case DT_RUNPATH:
9535 printf (_("Library runpath: [%s]"), name);
9536 break;
9537
9538 default:
9539 print_vma (entry->d_un.d_val, PREFIX_HEX);
9540 break;
9541 }
9542 }
9543 else
9544 print_vma (entry->d_un.d_val, PREFIX_HEX);
9545
9546 putchar ('\n');
9547 }
9548 break;
9549
9550 case DT_PLTRELSZ:
9551 case DT_RELASZ :
9552 case DT_STRSZ :
9553 case DT_RELSZ :
9554 case DT_RELAENT :
9555 case DT_SYMENT :
9556 case DT_RELENT :
9557 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9558 case DT_PLTPADSZ:
9559 case DT_MOVEENT :
9560 case DT_MOVESZ :
9561 case DT_INIT_ARRAYSZ:
9562 case DT_FINI_ARRAYSZ:
9563 case DT_GNU_CONFLICTSZ:
9564 case DT_GNU_LIBLISTSZ:
9565 if (do_dynamic)
9566 {
9567 print_vma (entry->d_un.d_val, UNSIGNED);
9568 printf (_(" (bytes)\n"));
9569 }
9570 break;
9571
9572 case DT_VERDEFNUM:
9573 case DT_VERNEEDNUM:
9574 case DT_RELACOUNT:
9575 case DT_RELCOUNT:
9576 if (do_dynamic)
9577 {
9578 print_vma (entry->d_un.d_val, UNSIGNED);
9579 putchar ('\n');
9580 }
9581 break;
9582
9583 case DT_SYMINSZ:
9584 case DT_SYMINENT:
9585 case DT_SYMINFO:
9586 case DT_USED:
9587 case DT_INIT_ARRAY:
9588 case DT_FINI_ARRAY:
9589 if (do_dynamic)
9590 {
9591 if (entry->d_tag == DT_USED
9592 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9593 {
9594 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9595
9596 if (*name)
9597 {
9598 printf (_("Not needed object: [%s]\n"), name);
9599 break;
9600 }
9601 }
9602
9603 print_vma (entry->d_un.d_val, PREFIX_HEX);
9604 putchar ('\n');
9605 }
9606 break;
9607
9608 case DT_BIND_NOW:
9609 /* The value of this entry is ignored. */
9610 if (do_dynamic)
9611 putchar ('\n');
9612 break;
9613
9614 case DT_GNU_PRELINKED:
9615 if (do_dynamic)
9616 {
9617 struct tm * tmp;
9618 time_t atime = entry->d_un.d_val;
9619
9620 tmp = gmtime (&atime);
9621 /* PR 17533 file: 041-1244816-0.004. */
9622 if (tmp == NULL)
9623 printf (_("<corrupt time val: %lx"),
9624 (unsigned long) atime);
9625 else
9626 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9627 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9628 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9629
9630 }
9631 break;
9632
9633 case DT_GNU_HASH:
9634 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9635 if (do_dynamic)
9636 {
9637 print_vma (entry->d_un.d_val, PREFIX_HEX);
9638 putchar ('\n');
9639 }
9640 break;
9641
9642 default:
9643 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9644 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9645 entry->d_un.d_val;
9646
9647 if (do_dynamic)
9648 {
9649 switch (elf_header.e_machine)
9650 {
9651 case EM_MIPS:
9652 case EM_MIPS_RS3_LE:
9653 dynamic_section_mips_val (entry);
9654 break;
9655 case EM_PARISC:
9656 dynamic_section_parisc_val (entry);
9657 break;
9658 case EM_IA_64:
9659 dynamic_section_ia64_val (entry);
9660 break;
9661 default:
9662 print_vma (entry->d_un.d_val, PREFIX_HEX);
9663 putchar ('\n');
9664 }
9665 }
9666 break;
9667 }
9668 }
9669
9670 return 1;
9671}
9672
9673static char *
9674get_ver_flags (unsigned int flags)
9675{
9676 static char buff[32];
9677
9678 buff[0] = 0;
9679
9680 if (flags == 0)
9681 return _("none");
9682
9683 if (flags & VER_FLG_BASE)
9684 strcat (buff, "BASE ");
9685
9686 if (flags & VER_FLG_WEAK)
9687 {
9688 if (flags & VER_FLG_BASE)
9689 strcat (buff, "| ");
9690
9691 strcat (buff, "WEAK ");
9692 }
9693
9694 if (flags & VER_FLG_INFO)
9695 {
9696 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9697 strcat (buff, "| ");
9698
9699 strcat (buff, "INFO ");
9700 }
9701
9702 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9703 strcat (buff, _("| <unknown>"));
9704
9705 return buff;
9706}
9707
9708/* Display the contents of the version sections. */
9709
9710static int
9711process_version_sections (FILE * file)
9712{
9713 Elf_Internal_Shdr * section;
9714 unsigned i;
9715 int found = 0;
9716
9717 if (! do_version)
9718 return 1;
9719
9720 for (i = 0, section = section_headers;
9721 i < elf_header.e_shnum;
9722 i++, section++)
9723 {
9724 switch (section->sh_type)
9725 {
9726 case SHT_GNU_verdef:
9727 {
9728 Elf_External_Verdef * edefs;
9729 unsigned int idx;
9730 unsigned int cnt;
9731 char * endbuf;
9732
9733 found = 1;
9734
9735 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9736 printable_section_name (section),
9737 section->sh_info);
9738
9739 printf (_(" Addr: 0x"));
9740 printf_vma (section->sh_addr);
9741 printf (_(" Offset: %#08lx Link: %u (%s)"),
9742 (unsigned long) section->sh_offset, section->sh_link,
9743 printable_section_name_from_index (section->sh_link));
9744
9745 edefs = (Elf_External_Verdef *)
9746 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9747 _("version definition section"));
9748 if (!edefs)
9749 break;
9750 endbuf = (char *) edefs + section->sh_size;
9751
9752 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9753 {
9754 char * vstart;
9755 Elf_External_Verdef * edef;
9756 Elf_Internal_Verdef ent;
9757 Elf_External_Verdaux * eaux;
9758 Elf_Internal_Verdaux aux;
9759 int j;
9760 int isum;
9761
9762 /* Check for very large indicies. */
9763 if (idx > (size_t) (endbuf - (char *) edefs))
9764 break;
9765
9766 vstart = ((char *) edefs) + idx;
9767 if (vstart + sizeof (*edef) > endbuf)
9768 break;
9769
9770 edef = (Elf_External_Verdef *) vstart;
9771
9772 ent.vd_version = BYTE_GET (edef->vd_version);
9773 ent.vd_flags = BYTE_GET (edef->vd_flags);
9774 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9775 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9776 ent.vd_hash = BYTE_GET (edef->vd_hash);
9777 ent.vd_aux = BYTE_GET (edef->vd_aux);
9778 ent.vd_next = BYTE_GET (edef->vd_next);
9779
9780 printf (_(" %#06x: Rev: %d Flags: %s"),
9781 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9782
9783 printf (_(" Index: %d Cnt: %d "),
9784 ent.vd_ndx, ent.vd_cnt);
9785
9786 /* Check for overflow. */
9787 if (ent.vd_aux > (size_t) (endbuf - vstart))
9788 break;
9789
9790 vstart += ent.vd_aux;
9791
9792 eaux = (Elf_External_Verdaux *) vstart;
9793
9794 aux.vda_name = BYTE_GET (eaux->vda_name);
9795 aux.vda_next = BYTE_GET (eaux->vda_next);
9796
9797 if (VALID_DYNAMIC_NAME (aux.vda_name))
9798 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9799 else
9800 printf (_("Name index: %ld\n"), aux.vda_name);
9801
9802 isum = idx + ent.vd_aux;
9803
9804 for (j = 1; j < ent.vd_cnt; j++)
9805 {
9806 /* Check for overflow. */
9807 if (aux.vda_next > (size_t) (endbuf - vstart))
9808 break;
9809
9810 isum += aux.vda_next;
9811 vstart += aux.vda_next;
9812
9813 eaux = (Elf_External_Verdaux *) vstart;
9814 if (vstart + sizeof (*eaux) > endbuf)
9815 break;
9816
9817 aux.vda_name = BYTE_GET (eaux->vda_name);
9818 aux.vda_next = BYTE_GET (eaux->vda_next);
9819
9820 if (VALID_DYNAMIC_NAME (aux.vda_name))
9821 printf (_(" %#06x: Parent %d: %s\n"),
9822 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9823 else
9824 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9825 isum, j, aux.vda_name);
9826 }
9827
9828 if (j < ent.vd_cnt)
9829 printf (_(" Version def aux past end of section\n"));
9830
9831 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9832 if (idx + ent.vd_next <= idx)
9833 break;
9834
9835 idx += ent.vd_next;
9836 }
9837
9838 if (cnt < section->sh_info)
9839 printf (_(" Version definition past end of section\n"));
9840
9841 free (edefs);
9842 }
9843 break;
9844
9845 case SHT_GNU_verneed:
9846 {
9847 Elf_External_Verneed * eneed;
9848 unsigned int idx;
9849 unsigned int cnt;
9850 char * endbuf;
9851
9852 found = 1;
9853
9854 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9855 printable_section_name (section), section->sh_info);
9856
9857 printf (_(" Addr: 0x"));
9858 printf_vma (section->sh_addr);
9859 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9860 (unsigned long) section->sh_offset, section->sh_link,
9861 printable_section_name_from_index (section->sh_link));
9862
9863 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9864 section->sh_offset, 1,
9865 section->sh_size,
9866 _("Version Needs section"));
9867 if (!eneed)
9868 break;
9869 endbuf = (char *) eneed + section->sh_size;
9870
9871 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9872 {
9873 Elf_External_Verneed * entry;
9874 Elf_Internal_Verneed ent;
9875 int j;
9876 int isum;
9877 char * vstart;
9878
9879 if (idx > (size_t) (endbuf - (char *) eneed))
9880 break;
9881
9882 vstart = ((char *) eneed) + idx;
9883 if (vstart + sizeof (*entry) > endbuf)
9884 break;
9885
9886 entry = (Elf_External_Verneed *) vstart;
9887
9888 ent.vn_version = BYTE_GET (entry->vn_version);
9889 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9890 ent.vn_file = BYTE_GET (entry->vn_file);
9891 ent.vn_aux = BYTE_GET (entry->vn_aux);
9892 ent.vn_next = BYTE_GET (entry->vn_next);
9893
9894 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9895
9896 if (VALID_DYNAMIC_NAME (ent.vn_file))
9897 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9898 else
9899 printf (_(" File: %lx"), ent.vn_file);
9900
9901 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9902
9903 /* Check for overflow. */
9904 if (ent.vn_aux > (size_t) (endbuf - vstart))
9905 break;
9906 vstart += ent.vn_aux;
9907
9908 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9909 {
9910 Elf_External_Vernaux * eaux;
9911 Elf_Internal_Vernaux aux;
9912
9913 if (vstart + sizeof (*eaux) > endbuf)
9914 break;
9915 eaux = (Elf_External_Vernaux *) vstart;
9916
9917 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9918 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9919 aux.vna_other = BYTE_GET (eaux->vna_other);
9920 aux.vna_name = BYTE_GET (eaux->vna_name);
9921 aux.vna_next = BYTE_GET (eaux->vna_next);
9922
9923 if (VALID_DYNAMIC_NAME (aux.vna_name))
9924 printf (_(" %#06x: Name: %s"),
9925 isum, GET_DYNAMIC_NAME (aux.vna_name));
9926 else
9927 printf (_(" %#06x: Name index: %lx"),
9928 isum, aux.vna_name);
9929
9930 printf (_(" Flags: %s Version: %d\n"),
9931 get_ver_flags (aux.vna_flags), aux.vna_other);
9932
9933 /* Check for overflow. */
9934 if (aux.vna_next > (size_t) (endbuf - vstart)
9935 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9936 {
9937 warn (_("Invalid vna_next field of %lx\n"),
9938 aux.vna_next);
9939 j = ent.vn_cnt;
9940 break;
9941 }
9942 isum += aux.vna_next;
9943 vstart += aux.vna_next;
9944 }
9945
9946 if (j < ent.vn_cnt)
9947 warn (_("Missing Version Needs auxillary information\n"));
9948
9949 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9950 {
9951 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9952 cnt = section->sh_info;
9953 break;
9954 }
9955 idx += ent.vn_next;
9956 }
9957
9958 if (cnt < section->sh_info)
9959 warn (_("Missing Version Needs information\n"));
9960
9961 free (eneed);
9962 }
9963 break;
9964
9965 case SHT_GNU_versym:
9966 {
9967 Elf_Internal_Shdr * link_section;
9968 size_t total;
9969 unsigned int cnt;
9970 unsigned char * edata;
9971 unsigned short * data;
9972 char * strtab;
9973 Elf_Internal_Sym * symbols;
9974 Elf_Internal_Shdr * string_sec;
9975 unsigned long num_syms;
9976 long off;
9977
9978 if (section->sh_link >= elf_header.e_shnum)
9979 break;
9980
9981 link_section = section_headers + section->sh_link;
9982 total = section->sh_size / sizeof (Elf_External_Versym);
9983
9984 if (link_section->sh_link >= elf_header.e_shnum)
9985 break;
9986
9987 found = 1;
9988
9989 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9990 if (symbols == NULL)
9991 break;
9992
9993 string_sec = section_headers + link_section->sh_link;
9994
9995 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9996 string_sec->sh_size,
9997 _("version string table"));
9998 if (!strtab)
9999 {
10000 free (symbols);
10001 break;
10002 }
10003
10004 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10005 printable_section_name (section), (unsigned long) total);
10006
10007 printf (_(" Addr: "));
10008 printf_vma (section->sh_addr);
10009 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10010 (unsigned long) section->sh_offset, section->sh_link,
10011 printable_section_name (link_section));
10012
10013 off = offset_from_vma (file,
10014 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10015 total * sizeof (short));
10016 edata = (unsigned char *) get_data (NULL, file, off, total,
10017 sizeof (short),
10018 _("version symbol data"));
10019 if (!edata)
10020 {
10021 free (strtab);
10022 free (symbols);
10023 break;
10024 }
10025
10026 data = (short unsigned int *) cmalloc (total, sizeof (short));
10027
10028 for (cnt = total; cnt --;)
10029 data[cnt] = byte_get (edata + cnt * sizeof (short),
10030 sizeof (short));
10031
10032 free (edata);
10033
10034 for (cnt = 0; cnt < total; cnt += 4)
10035 {
10036 int j, nn;
10037 char *name;
10038 char *invalid = _("*invalid*");
10039
10040 printf (" %03x:", cnt);
10041
10042 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10043 switch (data[cnt + j])
10044 {
10045 case 0:
10046 fputs (_(" 0 (*local*) "), stdout);
10047 break;
10048
10049 case 1:
10050 fputs (_(" 1 (*global*) "), stdout);
10051 break;
10052
10053 default:
10054 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10055 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10056
10057 /* If this index value is greater than the size of the symbols
10058 array, break to avoid an out-of-bounds read. */
10059 if ((unsigned long)(cnt + j) >= num_syms)
10060 {
10061 warn (_("invalid index into symbol array\n"));
10062 break;
10063 }
10064
10065 name = NULL;
10066 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10067 {
10068 Elf_Internal_Verneed ivn;
10069 unsigned long offset;
10070
10071 offset = offset_from_vma
10072 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10073 sizeof (Elf_External_Verneed));
10074
10075 do
10076 {
10077 Elf_Internal_Vernaux ivna;
10078 Elf_External_Verneed evn;
10079 Elf_External_Vernaux evna;
10080 unsigned long a_off;
10081
10082 if (get_data (&evn, file, offset, sizeof (evn), 1,
10083 _("version need")) == NULL)
10084 break;
10085
10086 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10087 ivn.vn_next = BYTE_GET (evn.vn_next);
10088
10089 a_off = offset + ivn.vn_aux;
10090
10091 do
10092 {
10093 if (get_data (&evna, file, a_off, sizeof (evna),
10094 1, _("version need aux (2)")) == NULL)
10095 {
10096 ivna.vna_next = 0;
10097 ivna.vna_other = 0;
10098 }
10099 else
10100 {
10101 ivna.vna_next = BYTE_GET (evna.vna_next);
10102 ivna.vna_other = BYTE_GET (evna.vna_other);
10103 }
10104
10105 a_off += ivna.vna_next;
10106 }
10107 while (ivna.vna_other != data[cnt + j]
10108 && ivna.vna_next != 0);
10109
10110 if (ivna.vna_other == data[cnt + j])
10111 {
10112 ivna.vna_name = BYTE_GET (evna.vna_name);
10113
10114 if (ivna.vna_name >= string_sec->sh_size)
10115 name = invalid;
10116 else
10117 name = strtab + ivna.vna_name;
10118 break;
10119 }
10120
10121 offset += ivn.vn_next;
10122 }
10123 while (ivn.vn_next);
10124 }
10125
10126 if (data[cnt + j] != 0x8001
10127 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10128 {
10129 Elf_Internal_Verdef ivd;
10130 Elf_External_Verdef evd;
10131 unsigned long offset;
10132
10133 offset = offset_from_vma
10134 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10135 sizeof evd);
10136
10137 do
10138 {
10139 if (get_data (&evd, file, offset, sizeof (evd), 1,
10140 _("version def")) == NULL)
10141 {
10142 ivd.vd_next = 0;
10143 /* PR 17531: file: 046-1082287-0.004. */
10144 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10145 break;
10146 }
10147 else
10148 {
10149 ivd.vd_next = BYTE_GET (evd.vd_next);
10150 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10151 }
10152
10153 offset += ivd.vd_next;
10154 }
10155 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10156 && ivd.vd_next != 0);
10157
10158 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10159 {
10160 Elf_External_Verdaux evda;
10161 Elf_Internal_Verdaux ivda;
10162
10163 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10164
10165 if (get_data (&evda, file,
10166 offset - ivd.vd_next + ivd.vd_aux,
10167 sizeof (evda), 1,
10168 _("version def aux")) == NULL)
10169 break;
10170
10171 ivda.vda_name = BYTE_GET (evda.vda_name);
10172
10173 if (ivda.vda_name >= string_sec->sh_size)
10174 name = invalid;
10175 else if (name != NULL && name != invalid)
10176 name = _("*both*");
10177 else
10178 name = strtab + ivda.vda_name;
10179 }
10180 }
10181 if (name != NULL)
10182 nn += printf ("(%s%-*s",
10183 name,
10184 12 - (int) strlen (name),
10185 ")");
10186
10187 if (nn < 18)
10188 printf ("%*c", 18 - nn, ' ');
10189 }
10190
10191 putchar ('\n');
10192 }
10193
10194 free (data);
10195 free (strtab);
10196 free (symbols);
10197 }
10198 break;
10199
10200 default:
10201 break;
10202 }
10203 }
10204
10205 if (! found)
10206 printf (_("\nNo version information found in this file.\n"));
10207
10208 return 1;
10209}
10210
10211static const char *
10212get_symbol_binding (unsigned int binding)
10213{
10214 static char buff[32];
10215
10216 switch (binding)
10217 {
10218 case STB_LOCAL: return "LOCAL";
10219 case STB_GLOBAL: return "GLOBAL";
10220 case STB_WEAK: return "WEAK";
10221 default:
10222 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10223 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10224 binding);
10225 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10226 {
10227 if (binding == STB_GNU_UNIQUE
10228 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10229 /* GNU is still using the default value 0. */
10230 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10231 return "UNIQUE";
10232 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10233 }
10234 else
10235 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10236 return buff;
10237 }
10238}
10239
10240static const char *
10241get_symbol_type (unsigned int type)
10242{
10243 static char buff[32];
10244
10245 switch (type)
10246 {
10247 case STT_NOTYPE: return "NOTYPE";
10248 case STT_OBJECT: return "OBJECT";
10249 case STT_FUNC: return "FUNC";
10250 case STT_SECTION: return "SECTION";
10251 case STT_FILE: return "FILE";
10252 case STT_COMMON: return "COMMON";
10253 case STT_TLS: return "TLS";
10254 case STT_RELC: return "RELC";
10255 case STT_SRELC: return "SRELC";
10256 default:
10257 if (type >= STT_LOPROC && type <= STT_HIPROC)
10258 {
10259 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10260 return "THUMB_FUNC";
10261
10262 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10263 return "REGISTER";
10264
10265 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10266 return "PARISC_MILLI";
10267
10268 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10269 }
10270 else if (type >= STT_LOOS && type <= STT_HIOS)
10271 {
10272 if (elf_header.e_machine == EM_PARISC)
10273 {
10274 if (type == STT_HP_OPAQUE)
10275 return "HP_OPAQUE";
10276 if (type == STT_HP_STUB)
10277 return "HP_STUB";
10278 }
10279
10280 if (type == STT_GNU_IFUNC
10281 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10282 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10283 /* GNU is still using the default value 0. */
10284 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10285 return "IFUNC";
10286
10287 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10288 }
10289 else
10290 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10291 return buff;
10292 }
10293}
10294
10295static const char *
10296get_symbol_visibility (unsigned int visibility)
10297{
10298 switch (visibility)
10299 {
10300 case STV_DEFAULT: return "DEFAULT";
10301 case STV_INTERNAL: return "INTERNAL";
10302 case STV_HIDDEN: return "HIDDEN";
10303 case STV_PROTECTED: return "PROTECTED";
10304 default:
10305 error (_("Unrecognized visibility value: %u"), visibility);
10306 return _("<unknown>");
10307 }
10308}
10309
10310static const char *
10311get_solaris_symbol_visibility (unsigned int visibility)
10312{
10313 switch (visibility)
10314 {
10315 case 4: return "EXPORTED";
10316 case 5: return "SINGLETON";
10317 case 6: return "ELIMINATE";
10318 default: return get_symbol_visibility (visibility);
10319 }
10320}
10321
10322static const char *
10323get_mips_symbol_other (unsigned int other)
10324{
10325 switch (other)
10326 {
10327 case STO_OPTIONAL:
10328 return "OPTIONAL";
10329 case STO_MIPS_PLT:
10330 return "MIPS PLT";
10331 case STO_MIPS_PIC:
10332 return "MIPS PIC";
10333 case STO_MICROMIPS:
10334 return "MICROMIPS";
10335 case STO_MICROMIPS | STO_MIPS_PIC:
10336 return "MICROMIPS, MIPS PIC";
10337 case STO_MIPS16:
10338 return "MIPS16";
10339 default:
10340 return NULL;
10341 }
10342}
10343
10344static const char *
10345get_ia64_symbol_other (unsigned int other)
10346{
10347 if (is_ia64_vms ())
10348 {
10349 static char res[32];
10350
10351 res[0] = 0;
10352
10353 /* Function types is for images and .STB files only. */
10354 switch (elf_header.e_type)
10355 {
10356 case ET_DYN:
10357 case ET_EXEC:
10358 switch (VMS_ST_FUNC_TYPE (other))
10359 {
10360 case VMS_SFT_CODE_ADDR:
10361 strcat (res, " CA");
10362 break;
10363 case VMS_SFT_SYMV_IDX:
10364 strcat (res, " VEC");
10365 break;
10366 case VMS_SFT_FD:
10367 strcat (res, " FD");
10368 break;
10369 case VMS_SFT_RESERVE:
10370 strcat (res, " RSV");
10371 break;
10372 default:
10373 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10374 VMS_ST_FUNC_TYPE (other));
10375 strcat (res, " <unknown>");
10376 break;
10377 }
10378 break;
10379 default:
10380 break;
10381 }
10382 switch (VMS_ST_LINKAGE (other))
10383 {
10384 case VMS_STL_IGNORE:
10385 strcat (res, " IGN");
10386 break;
10387 case VMS_STL_RESERVE:
10388 strcat (res, " RSV");
10389 break;
10390 case VMS_STL_STD:
10391 strcat (res, " STD");
10392 break;
10393 case VMS_STL_LNK:
10394 strcat (res, " LNK");
10395 break;
10396 default:
10397 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10398 VMS_ST_LINKAGE (other));
10399 strcat (res, " <unknown>");
10400 break;
10401 }
10402
10403 if (res[0] != 0)
10404 return res + 1;
10405 else
10406 return res;
10407 }
10408 return NULL;
10409}
10410
10411static const char *
10412get_ppc64_symbol_other (unsigned int other)
10413{
10414 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10415 {
10416 static char buf[32];
10417 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10418 PPC64_LOCAL_ENTRY_OFFSET (other));
10419 return buf;
10420 }
10421 return NULL;
10422}
10423
10424static const char *
10425get_symbol_other (unsigned int other)
10426{
10427 const char * result = NULL;
10428 static char buff [32];
10429
10430 if (other == 0)
10431 return "";
10432
10433 switch (elf_header.e_machine)
10434 {
10435 case EM_MIPS:
10436 result = get_mips_symbol_other (other);
10437 break;
10438 case EM_IA_64:
10439 result = get_ia64_symbol_other (other);
10440 break;
10441 case EM_PPC64:
10442 result = get_ppc64_symbol_other (other);
10443 break;
10444 default:
10445 result = NULL;
10446 break;
10447 }
10448
10449 if (result)
10450 return result;
10451
10452 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10453 return buff;
10454}
10455
10456static const char *
10457get_symbol_index_type (unsigned int type)
10458{
10459 static char buff[32];
10460
10461 switch (type)
10462 {
10463 case SHN_UNDEF: return "UND";
10464 case SHN_ABS: return "ABS";
10465 case SHN_COMMON: return "COM";
10466 default:
10467 if (type == SHN_IA_64_ANSI_COMMON
10468 && elf_header.e_machine == EM_IA_64
10469 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10470 return "ANSI_COM";
10471 else if ((elf_header.e_machine == EM_X86_64
10472 || elf_header.e_machine == EM_L1OM
10473 || elf_header.e_machine == EM_K1OM)
10474 && type == SHN_X86_64_LCOMMON)
10475 return "LARGE_COM";
10476 else if ((type == SHN_MIPS_SCOMMON
10477 && elf_header.e_machine == EM_MIPS)
10478 || (type == SHN_TIC6X_SCOMMON
10479 && elf_header.e_machine == EM_TI_C6000))
10480 return "SCOM";
10481 else if (type == SHN_MIPS_SUNDEFINED
10482 && elf_header.e_machine == EM_MIPS)
10483 return "SUND";
10484 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10485 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10486 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10487 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10488 else if (type >= SHN_LORESERVE)
10489 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10490 else if (type >= elf_header.e_shnum)
10491 sprintf (buff, _("bad section index[%3d]"), type);
10492 else
10493 sprintf (buff, "%3d", type);
10494 break;
10495 }
10496
10497 return buff;
10498}
10499
10500static bfd_vma *
10501get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10502{
10503 unsigned char * e_data;
10504 bfd_vma * i_data;
10505
10506 /* If the size_t type is smaller than the bfd_size_type, eg because
10507 you are building a 32-bit tool on a 64-bit host, then make sure
10508 that when (number) is cast to (size_t) no information is lost. */
10509 if (sizeof (size_t) < sizeof (bfd_size_type)
10510 && (bfd_size_type) ((size_t) number) != number)
10511 {
10512 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10513 " elements of size %u\n"),
10514 number, ent_size);
10515 return NULL;
10516 }
10517
10518 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10519 attempting to allocate memory when the read is bound to fail. */
10520 if (ent_size * number > current_file_size)
10521 {
10522 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10523 number);
10524 return NULL;
10525 }
10526
10527 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10528 if (e_data == NULL)
10529 {
10530 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10531 number);
10532 return NULL;
10533 }
10534
10535 if (fread (e_data, ent_size, (size_t) number, file) != number)
10536 {
10537 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10538 number * ent_size);
10539 free (e_data);
10540 return NULL;
10541 }
10542
10543 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10544 if (i_data == NULL)
10545 {
10546 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10547 " dynamic entries\n"),
10548 number);
10549 free (e_data);
10550 return NULL;
10551 }
10552
10553 while (number--)
10554 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10555
10556 free (e_data);
10557
10558 return i_data;
10559}
10560
10561static void
10562print_dynamic_symbol (bfd_vma si, unsigned long hn)
10563{
10564 Elf_Internal_Sym * psym;
10565 int n;
10566
10567 n = print_vma (si, DEC_5);
10568 if (n < 5)
10569 fputs (&" "[n], stdout);
10570 printf (" %3lu: ", hn);
10571
10572 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10573 {
10574 printf (_("<No info available for dynamic symbol number %lu>\n"),
10575 (unsigned long) si);
10576 return;
10577 }
10578
10579 psym = dynamic_symbols + si;
10580 print_vma (psym->st_value, LONG_HEX);
10581 putchar (' ');
10582 print_vma (psym->st_size, DEC_5);
10583
10584 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10585 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10586
10587 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10588 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10589 else
10590 {
10591 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10592
10593 printf (" %-7s", get_symbol_visibility (vis));
10594 /* Check to see if any other bits in the st_other field are set.
10595 Note - displaying this information disrupts the layout of the
10596 table being generated, but for the moment this case is very
10597 rare. */
10598 if (psym->st_other ^ vis)
10599 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10600 }
10601
10602 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10603 if (VALID_DYNAMIC_NAME (psym->st_name))
10604 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10605 else
10606 printf (_(" <corrupt: %14ld>"), psym->st_name);
10607 putchar ('\n');
10608}
10609
10610static const char *
10611get_symbol_version_string (FILE *file, int is_dynsym,
10612 const char *strtab,
10613 unsigned long int strtab_size,
10614 unsigned int si, Elf_Internal_Sym *psym,
10615 enum versioned_symbol_info *sym_info,
10616 unsigned short *vna_other)
10617{
10618 unsigned char data[2];
10619 unsigned short vers_data;
10620 unsigned long offset;
10621
10622 if (!is_dynsym
10623 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10624 return NULL;
10625
10626 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10627 sizeof data + si * sizeof (vers_data));
10628
10629 if (get_data (&data, file, offset + si * sizeof (vers_data),
10630 sizeof (data), 1, _("version data")) == NULL)
10631 return NULL;
10632
10633 vers_data = byte_get (data, 2);
10634
10635 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10636 return NULL;
10637
10638 /* Usually we'd only see verdef for defined symbols, and verneed for
10639 undefined symbols. However, symbols defined by the linker in
10640 .dynbss for variables copied from a shared library in order to
10641 avoid text relocations are defined yet have verneed. We could
10642 use a heuristic to detect the special case, for example, check
10643 for verneed first on symbols defined in SHT_NOBITS sections, but
10644 it is simpler and more reliable to just look for both verdef and
10645 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10646
10647 if (psym->st_shndx != SHN_UNDEF
10648 && vers_data != 0x8001
10649 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10650 {
10651 Elf_Internal_Verdef ivd;
10652 Elf_Internal_Verdaux ivda;
10653 Elf_External_Verdaux evda;
10654 unsigned long off;
10655
10656 off = offset_from_vma (file,
10657 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10658 sizeof (Elf_External_Verdef));
10659
10660 do
10661 {
10662 Elf_External_Verdef evd;
10663
10664 if (get_data (&evd, file, off, sizeof (evd), 1,
10665 _("version def")) == NULL)
10666 {
10667 ivd.vd_ndx = 0;
10668 ivd.vd_aux = 0;
10669 ivd.vd_next = 0;
10670 }
10671 else
10672 {
10673 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10674 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10675 ivd.vd_next = BYTE_GET (evd.vd_next);
10676 }
10677
10678 off += ivd.vd_next;
10679 }
10680 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10681
10682 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10683 {
10684 off -= ivd.vd_next;
10685 off += ivd.vd_aux;
10686
10687 if (get_data (&evda, file, off, sizeof (evda), 1,
10688 _("version def aux")) != NULL)
10689 {
10690 ivda.vda_name = BYTE_GET (evda.vda_name);
10691
10692 if (psym->st_name != ivda.vda_name)
10693 {
10694 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10695 ? symbol_hidden : symbol_public);
10696 return (ivda.vda_name < strtab_size
10697 ? strtab + ivda.vda_name : _("<corrupt>"));
10698 }
10699 }
10700 }
10701 }
10702
10703 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10704 {
10705 Elf_External_Verneed evn;
10706 Elf_Internal_Verneed ivn;
10707 Elf_Internal_Vernaux ivna;
10708
10709 offset = offset_from_vma (file,
10710 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10711 sizeof evn);
10712 do
10713 {
10714 unsigned long vna_off;
10715
10716 if (get_data (&evn, file, offset, sizeof (evn), 1,
10717 _("version need")) == NULL)
10718 {
10719 ivna.vna_next = 0;
10720 ivna.vna_other = 0;
10721 ivna.vna_name = 0;
10722 break;
10723 }
10724
10725 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10726 ivn.vn_next = BYTE_GET (evn.vn_next);
10727
10728 vna_off = offset + ivn.vn_aux;
10729
10730 do
10731 {
10732 Elf_External_Vernaux evna;
10733
10734 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10735 _("version need aux (3)")) == NULL)
10736 {
10737 ivna.vna_next = 0;
10738 ivna.vna_other = 0;
10739 ivna.vna_name = 0;
10740 }
10741 else
10742 {
10743 ivna.vna_other = BYTE_GET (evna.vna_other);
10744 ivna.vna_next = BYTE_GET (evna.vna_next);
10745 ivna.vna_name = BYTE_GET (evna.vna_name);
10746 }
10747
10748 vna_off += ivna.vna_next;
10749 }
10750 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
10751
10752 if (ivna.vna_other == vers_data)
10753 break;
10754
10755 offset += ivn.vn_next;
10756 }
10757 while (ivn.vn_next != 0);
10758
10759 if (ivna.vna_other == vers_data)
10760 {
10761 *sym_info = symbol_undefined;
10762 *vna_other = ivna.vna_other;
10763 return (ivna.vna_name < strtab_size
10764 ? strtab + ivna.vna_name : _("<corrupt>"));
10765 }
10766 }
10767 return NULL;
10768}
10769
10770/* Dump the symbol table. */
10771static int
10772process_symbol_table (FILE * file)
10773{
10774 Elf_Internal_Shdr * section;
10775 bfd_size_type nbuckets = 0;
10776 bfd_size_type nchains = 0;
10777 bfd_vma * buckets = NULL;
10778 bfd_vma * chains = NULL;
10779 bfd_vma ngnubuckets = 0;
10780 bfd_vma * gnubuckets = NULL;
10781 bfd_vma * gnuchains = NULL;
10782 bfd_vma gnusymidx = 0;
10783 bfd_size_type ngnuchains = 0;
10784
10785 if (!do_syms && !do_dyn_syms && !do_histogram)
10786 return 1;
10787
10788 if (dynamic_info[DT_HASH]
10789 && (do_histogram
10790 || (do_using_dynamic
10791 && !do_dyn_syms
10792 && dynamic_strings != NULL)))
10793 {
10794 unsigned char nb[8];
10795 unsigned char nc[8];
10796 unsigned int hash_ent_size = 4;
10797
10798 if ((elf_header.e_machine == EM_ALPHA
10799 || elf_header.e_machine == EM_S390
10800 || elf_header.e_machine == EM_S390_OLD)
10801 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10802 hash_ent_size = 8;
10803
10804 if (fseek (file,
10805 (archive_file_offset
10806 + offset_from_vma (file, dynamic_info[DT_HASH],
10807 sizeof nb + sizeof nc)),
10808 SEEK_SET))
10809 {
10810 error (_("Unable to seek to start of dynamic information\n"));
10811 goto no_hash;
10812 }
10813
10814 if (fread (nb, hash_ent_size, 1, file) != 1)
10815 {
10816 error (_("Failed to read in number of buckets\n"));
10817 goto no_hash;
10818 }
10819
10820 if (fread (nc, hash_ent_size, 1, file) != 1)
10821 {
10822 error (_("Failed to read in number of chains\n"));
10823 goto no_hash;
10824 }
10825
10826 nbuckets = byte_get (nb, hash_ent_size);
10827 nchains = byte_get (nc, hash_ent_size);
10828
10829 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10830 chains = get_dynamic_data (file, nchains, hash_ent_size);
10831
10832 no_hash:
10833 if (buckets == NULL || chains == NULL)
10834 {
10835 if (do_using_dynamic)
10836 return 0;
10837 free (buckets);
10838 free (chains);
10839 buckets = NULL;
10840 chains = NULL;
10841 nbuckets = 0;
10842 nchains = 0;
10843 }
10844 }
10845
10846 if (dynamic_info_DT_GNU_HASH
10847 && (do_histogram
10848 || (do_using_dynamic
10849 && !do_dyn_syms
10850 && dynamic_strings != NULL)))
10851 {
10852 unsigned char nb[16];
10853 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10854 bfd_vma buckets_vma;
10855
10856 if (fseek (file,
10857 (archive_file_offset
10858 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10859 sizeof nb)),
10860 SEEK_SET))
10861 {
10862 error (_("Unable to seek to start of dynamic information\n"));
10863 goto no_gnu_hash;
10864 }
10865
10866 if (fread (nb, 16, 1, file) != 1)
10867 {
10868 error (_("Failed to read in number of buckets\n"));
10869 goto no_gnu_hash;
10870 }
10871
10872 ngnubuckets = byte_get (nb, 4);
10873 gnusymidx = byte_get (nb + 4, 4);
10874 bitmaskwords = byte_get (nb + 8, 4);
10875 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10876 if (is_32bit_elf)
10877 buckets_vma += bitmaskwords * 4;
10878 else
10879 buckets_vma += bitmaskwords * 8;
10880
10881 if (fseek (file,
10882 (archive_file_offset
10883 + offset_from_vma (file, buckets_vma, 4)),
10884 SEEK_SET))
10885 {
10886 error (_("Unable to seek to start of dynamic information\n"));
10887 goto no_gnu_hash;
10888 }
10889
10890 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10891
10892 if (gnubuckets == NULL)
10893 goto no_gnu_hash;
10894
10895 for (i = 0; i < ngnubuckets; i++)
10896 if (gnubuckets[i] != 0)
10897 {
10898 if (gnubuckets[i] < gnusymidx)
10899 return 0;
10900
10901 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10902 maxchain = gnubuckets[i];
10903 }
10904
10905 if (maxchain == 0xffffffff)
10906 goto no_gnu_hash;
10907
10908 maxchain -= gnusymidx;
10909
10910 if (fseek (file,
10911 (archive_file_offset
10912 + offset_from_vma (file, buckets_vma
10913 + 4 * (ngnubuckets + maxchain), 4)),
10914 SEEK_SET))
10915 {
10916 error (_("Unable to seek to start of dynamic information\n"));
10917 goto no_gnu_hash;
10918 }
10919
10920 do
10921 {
10922 if (fread (nb, 4, 1, file) != 1)
10923 {
10924 error (_("Failed to determine last chain length\n"));
10925 goto no_gnu_hash;
10926 }
10927
10928 if (maxchain + 1 == 0)
10929 goto no_gnu_hash;
10930
10931 ++maxchain;
10932 }
10933 while ((byte_get (nb, 4) & 1) == 0);
10934
10935 if (fseek (file,
10936 (archive_file_offset
10937 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10938 SEEK_SET))
10939 {
10940 error (_("Unable to seek to start of dynamic information\n"));
10941 goto no_gnu_hash;
10942 }
10943
10944 gnuchains = get_dynamic_data (file, maxchain, 4);
10945 ngnuchains = maxchain;
10946
10947 no_gnu_hash:
10948 if (gnuchains == NULL)
10949 {
10950 free (gnubuckets);
10951 gnubuckets = NULL;
10952 ngnubuckets = 0;
10953 if (do_using_dynamic)
10954 return 0;
10955 }
10956 }
10957
10958 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10959 && do_syms
10960 && do_using_dynamic
10961 && dynamic_strings != NULL
10962 && dynamic_symbols != NULL)
10963 {
10964 unsigned long hn;
10965
10966 if (dynamic_info[DT_HASH])
10967 {
10968 bfd_vma si;
10969
10970 printf (_("\nSymbol table for image:\n"));
10971 if (is_32bit_elf)
10972 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10973 else
10974 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10975
10976 for (hn = 0; hn < nbuckets; hn++)
10977 {
10978 if (! buckets[hn])
10979 continue;
10980
10981 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10982 print_dynamic_symbol (si, hn);
10983 }
10984 }
10985
10986 if (dynamic_info_DT_GNU_HASH)
10987 {
10988 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10989 if (is_32bit_elf)
10990 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10991 else
10992 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10993
10994 for (hn = 0; hn < ngnubuckets; ++hn)
10995 if (gnubuckets[hn] != 0)
10996 {
10997 bfd_vma si = gnubuckets[hn];
10998 bfd_vma off = si - gnusymidx;
10999
11000 do
11001 {
11002 print_dynamic_symbol (si, hn);
11003 si++;
11004 }
11005 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11006 }
11007 }
11008 }
11009 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11010 && section_headers != NULL)
11011 {
11012 unsigned int i;
11013
11014 for (i = 0, section = section_headers;
11015 i < elf_header.e_shnum;
11016 i++, section++)
11017 {
11018 unsigned int si;
11019 char * strtab = NULL;
11020 unsigned long int strtab_size = 0;
11021 Elf_Internal_Sym * symtab;
11022 Elf_Internal_Sym * psym;
11023 unsigned long num_syms;
11024
11025 if ((section->sh_type != SHT_SYMTAB
11026 && section->sh_type != SHT_DYNSYM)
11027 || (!do_syms
11028 && section->sh_type == SHT_SYMTAB))
11029 continue;
11030
11031 if (section->sh_entsize == 0)
11032 {
11033 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11034 printable_section_name (section));
11035 continue;
11036 }
11037
11038 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11039 printable_section_name (section),
11040 (unsigned long) (section->sh_size / section->sh_entsize));
11041
11042 if (is_32bit_elf)
11043 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11044 else
11045 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11046
11047 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11048 if (symtab == NULL)
11049 continue;
11050
11051 if (section->sh_link == elf_header.e_shstrndx)
11052 {
11053 strtab = string_table;
11054 strtab_size = string_table_length;
11055 }
11056 else if (section->sh_link < elf_header.e_shnum)
11057 {
11058 Elf_Internal_Shdr * string_sec;
11059
11060 string_sec = section_headers + section->sh_link;
11061
11062 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11063 1, string_sec->sh_size,
11064 _("string table"));
11065 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11066 }
11067
11068 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11069 {
11070 const char *version_string;
11071 enum versioned_symbol_info sym_info;
11072 unsigned short vna_other;
11073
11074 printf ("%6d: ", si);
11075 print_vma (psym->st_value, LONG_HEX);
11076 putchar (' ');
11077 print_vma (psym->st_size, DEC_5);
11078 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11079 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11080 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11081 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11082 else
11083 {
11084 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11085
11086 printf (" %-7s", get_symbol_visibility (vis));
11087 /* Check to see if any other bits in the st_other field are set.
11088 Note - displaying this information disrupts the layout of the
11089 table being generated, but for the moment this case is very rare. */
11090 if (psym->st_other ^ vis)
11091 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11092 }
11093 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11094 print_symbol (25, psym->st_name < strtab_size
11095 ? strtab + psym->st_name : _("<corrupt>"));
11096
11097 version_string
11098 = get_symbol_version_string (file,
11099 section->sh_type == SHT_DYNSYM,
11100 strtab, strtab_size, si,
11101 psym, &sym_info, &vna_other);
11102 if (version_string)
11103 {
11104 if (sym_info == symbol_undefined)
11105 printf ("@%s (%d)", version_string, vna_other);
11106 else
11107 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11108 version_string);
11109 }
11110
11111 putchar ('\n');
11112 }
11113
11114 free (symtab);
11115 if (strtab != string_table)
11116 free (strtab);
11117 }
11118 }
11119 else if (do_syms)
11120 printf
11121 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11122
11123 if (do_histogram && buckets != NULL)
11124 {
11125 unsigned long * lengths;
11126 unsigned long * counts;
11127 unsigned long hn;
11128 bfd_vma si;
11129 unsigned long maxlength = 0;
11130 unsigned long nzero_counts = 0;
11131 unsigned long nsyms = 0;
11132 unsigned long chained;
11133
11134 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11135 (unsigned long) nbuckets);
11136
11137 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11138 if (lengths == NULL)
11139 {
11140 error (_("Out of memory allocating space for histogram buckets\n"));
11141 return 0;
11142 }
11143
11144 printf (_(" Length Number %% of total Coverage\n"));
11145 for (hn = 0; hn < nbuckets; ++hn)
11146 {
11147 for (si = buckets[hn], chained = 0;
11148 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11149 si = chains[si], ++chained)
11150 {
11151 ++nsyms;
11152 if (maxlength < ++lengths[hn])
11153 ++maxlength;
11154 }
11155
11156 /* PR binutils/17531: A corrupt binary could contain broken
11157 histogram data. Do not go into an infinite loop trying
11158 to process it. */
11159 if (chained > nchains)
11160 {
11161 error (_("histogram chain is corrupt\n"));
11162 break;
11163 }
11164 }
11165
11166 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11167 if (counts == NULL)
11168 {
11169 free (lengths);
11170 error (_("Out of memory allocating space for histogram counts\n"));
11171 return 0;
11172 }
11173
11174 for (hn = 0; hn < nbuckets; ++hn)
11175 ++counts[lengths[hn]];
11176
11177 if (nbuckets > 0)
11178 {
11179 unsigned long i;
11180 printf (" 0 %-10lu (%5.1f%%)\n",
11181 counts[0], (counts[0] * 100.0) / nbuckets);
11182 for (i = 1; i <= maxlength; ++i)
11183 {
11184 nzero_counts += counts[i] * i;
11185 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11186 i, counts[i], (counts[i] * 100.0) / nbuckets,
11187 (nzero_counts * 100.0) / nsyms);
11188 }
11189 }
11190
11191 free (counts);
11192 free (lengths);
11193 }
11194
11195 if (buckets != NULL)
11196 {
11197 free (buckets);
11198 free (chains);
11199 }
11200
11201 if (do_histogram && gnubuckets != NULL)
11202 {
11203 unsigned long * lengths;
11204 unsigned long * counts;
11205 unsigned long hn;
11206 unsigned long maxlength = 0;
11207 unsigned long nzero_counts = 0;
11208 unsigned long nsyms = 0;
11209
11210 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11211 (unsigned long) ngnubuckets);
11212
11213 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11214 if (lengths == NULL)
11215 {
11216 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11217 return 0;
11218 }
11219
11220 printf (_(" Length Number %% of total Coverage\n"));
11221
11222 for (hn = 0; hn < ngnubuckets; ++hn)
11223 if (gnubuckets[hn] != 0)
11224 {
11225 bfd_vma off, length = 1;
11226
11227 for (off = gnubuckets[hn] - gnusymidx;
11228 /* PR 17531 file: 010-77222-0.004. */
11229 off < ngnuchains && (gnuchains[off] & 1) == 0;
11230 ++off)
11231 ++length;
11232 lengths[hn] = length;
11233 if (length > maxlength)
11234 maxlength = length;
11235 nsyms += length;
11236 }
11237
11238 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11239 if (counts == NULL)
11240 {
11241 free (lengths);
11242 error (_("Out of memory allocating space for gnu histogram counts\n"));
11243 return 0;
11244 }
11245
11246 for (hn = 0; hn < ngnubuckets; ++hn)
11247 ++counts[lengths[hn]];
11248
11249 if (ngnubuckets > 0)
11250 {
11251 unsigned long j;
11252 printf (" 0 %-10lu (%5.1f%%)\n",
11253 counts[0], (counts[0] * 100.0) / ngnubuckets);
11254 for (j = 1; j <= maxlength; ++j)
11255 {
11256 nzero_counts += counts[j] * j;
11257 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11258 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11259 (nzero_counts * 100.0) / nsyms);
11260 }
11261 }
11262
11263 free (counts);
11264 free (lengths);
11265 free (gnubuckets);
11266 free (gnuchains);
11267 }
11268
11269 return 1;
11270}
11271
11272static int
11273process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11274{
11275 unsigned int i;
11276
11277 if (dynamic_syminfo == NULL
11278 || !do_dynamic)
11279 /* No syminfo, this is ok. */
11280 return 1;
11281
11282 /* There better should be a dynamic symbol section. */
11283 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11284 return 0;
11285
11286 if (dynamic_addr)
11287 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11288 dynamic_syminfo_offset, dynamic_syminfo_nent);
11289
11290 printf (_(" Num: Name BoundTo Flags\n"));
11291 for (i = 0; i < dynamic_syminfo_nent; ++i)
11292 {
11293 unsigned short int flags = dynamic_syminfo[i].si_flags;
11294
11295 printf ("%4d: ", i);
11296 if (i >= num_dynamic_syms)
11297 printf (_("<corrupt index>"));
11298 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11299 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11300 else
11301 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11302 putchar (' ');
11303
11304 switch (dynamic_syminfo[i].si_boundto)
11305 {
11306 case SYMINFO_BT_SELF:
11307 fputs ("SELF ", stdout);
11308 break;
11309 case SYMINFO_BT_PARENT:
11310 fputs ("PARENT ", stdout);
11311 break;
11312 default:
11313 if (dynamic_syminfo[i].si_boundto > 0
11314 && dynamic_syminfo[i].si_boundto < dynamic_nent
11315 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11316 {
11317 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11318 putchar (' ' );
11319 }
11320 else
11321 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11322 break;
11323 }
11324
11325 if (flags & SYMINFO_FLG_DIRECT)
11326 printf (" DIRECT");
11327 if (flags & SYMINFO_FLG_PASSTHRU)
11328 printf (" PASSTHRU");
11329 if (flags & SYMINFO_FLG_COPY)
11330 printf (" COPY");
11331 if (flags & SYMINFO_FLG_LAZYLOAD)
11332 printf (" LAZYLOAD");
11333
11334 puts ("");
11335 }
11336
11337 return 1;
11338}
11339
11340/* Check to see if the given reloc needs to be handled in a target specific
11341 manner. If so then process the reloc and return TRUE otherwise return
11342 FALSE. */
11343
11344static bfd_boolean
11345target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11346 unsigned char * start,
11347 Elf_Internal_Sym * symtab)
11348{
11349 unsigned int reloc_type = get_reloc_type (reloc->r_info);
11350
11351 switch (elf_header.e_machine)
11352 {
11353 case EM_MSP430:
11354 case EM_MSP430_OLD:
11355 {
11356 static Elf_Internal_Sym * saved_sym = NULL;
11357
11358 switch (reloc_type)
11359 {
11360 case 10: /* R_MSP430_SYM_DIFF */
11361 if (uses_msp430x_relocs ())
11362 break;
11363 case 21: /* R_MSP430X_SYM_DIFF */
11364 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11365 return TRUE;
11366
11367 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11368 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11369 goto handle_sym_diff;
11370
11371 case 5: /* R_MSP430_16_BYTE */
11372 case 9: /* R_MSP430_8 */
11373 if (uses_msp430x_relocs ())
11374 break;
11375 goto handle_sym_diff;
11376
11377 case 2: /* R_MSP430_ABS16 */
11378 case 15: /* R_MSP430X_ABS16 */
11379 if (! uses_msp430x_relocs ())
11380 break;
11381 goto handle_sym_diff;
11382
11383 handle_sym_diff:
11384 if (saved_sym != NULL)
11385 {
11386 bfd_vma value;
11387
11388 value = reloc->r_addend
11389 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11390 - saved_sym->st_value);
11391
11392 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11393
11394 saved_sym = NULL;
11395 return TRUE;
11396 }
11397 break;
11398
11399 default:
11400 if (saved_sym != NULL)
11401 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11402 break;
11403 }
11404 break;
11405 }
11406
11407 case EM_MN10300:
11408 case EM_CYGNUS_MN10300:
11409 {
11410 static Elf_Internal_Sym * saved_sym = NULL;
11411
11412 switch (reloc_type)
11413 {
11414 case 34: /* R_MN10300_ALIGN */
11415 return TRUE;
11416 case 33: /* R_MN10300_SYM_DIFF */
11417 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11418 return TRUE;
11419 case 1: /* R_MN10300_32 */
11420 case 2: /* R_MN10300_16 */
11421 if (saved_sym != NULL)
11422 {
11423 bfd_vma value;
11424
11425 value = reloc->r_addend
11426 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11427 - saved_sym->st_value);
11428
11429 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11430
11431 saved_sym = NULL;
11432 return TRUE;
11433 }
11434 break;
11435 default:
11436 if (saved_sym != NULL)
11437 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11438 break;
11439 }
11440 break;
11441 }
11442
11443 case EM_RL78:
11444 {
11445 static bfd_vma saved_sym1 = 0;
11446 static bfd_vma saved_sym2 = 0;
11447 static bfd_vma value;
11448
11449 switch (reloc_type)
11450 {
11451 case 0x80: /* R_RL78_SYM. */
11452 saved_sym1 = saved_sym2;
11453 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11454 saved_sym2 += reloc->r_addend;
11455 return TRUE;
11456
11457 case 0x83: /* R_RL78_OPsub. */
11458 value = saved_sym1 - saved_sym2;
11459 saved_sym2 = saved_sym1 = 0;
11460 return TRUE;
11461 break;
11462
11463 case 0x41: /* R_RL78_ABS32. */
11464 byte_put (start + reloc->r_offset, value, 4);
11465 value = 0;
11466 return TRUE;
11467
11468 case 0x43: /* R_RL78_ABS16. */
11469 byte_put (start + reloc->r_offset, value, 2);
11470 value = 0;
11471 return TRUE;
11472
11473 default:
11474 break;
11475 }
11476 break;
11477 }
11478 }
11479
11480 return FALSE;
11481}
11482
11483/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11484 DWARF debug sections. This is a target specific test. Note - we do not
11485 go through the whole including-target-headers-multiple-times route, (as
11486 we have already done with <elf/h8.h>) because this would become very
11487 messy and even then this function would have to contain target specific
11488 information (the names of the relocs instead of their numeric values).
11489 FIXME: This is not the correct way to solve this problem. The proper way
11490 is to have target specific reloc sizing and typing functions created by
11491 the reloc-macros.h header, in the same way that it already creates the
11492 reloc naming functions. */
11493
11494static bfd_boolean
11495is_32bit_abs_reloc (unsigned int reloc_type)
11496{
11497 /* Please keep this table alpha-sorted for ease of visual lookup. */
11498 switch (elf_header.e_machine)
11499 {
11500 case EM_386:
11501 case EM_IAMCU:
11502 return reloc_type == 1; /* R_386_32. */
11503 case EM_68K:
11504 return reloc_type == 1; /* R_68K_32. */
11505 case EM_860:
11506 return reloc_type == 1; /* R_860_32. */
11507 case EM_960:
11508 return reloc_type == 2; /* R_960_32. */
11509 case EM_AARCH64:
11510 return reloc_type == 258; /* R_AARCH64_ABS32 */
11511 case EM_ADAPTEVA_EPIPHANY:
11512 return reloc_type == 3;
11513 case EM_ALPHA:
11514 return reloc_type == 1; /* R_ALPHA_REFLONG. */
11515 case EM_ARC:
11516 return reloc_type == 1; /* R_ARC_32. */
11517 case EM_ARC_COMPACT:
11518 case EM_ARC_COMPACT2:
11519 return reloc_type == 4; /* R_ARC_32. */
11520 case EM_ARM:
11521 return reloc_type == 2; /* R_ARM_ABS32 */
11522 case EM_AVR_OLD:
11523 case EM_AVR:
11524 return reloc_type == 1;
11525 case EM_BLACKFIN:
11526 return reloc_type == 0x12; /* R_byte4_data. */
11527 case EM_CRIS:
11528 return reloc_type == 3; /* R_CRIS_32. */
11529 case EM_CR16:
11530 return reloc_type == 3; /* R_CR16_NUM32. */
11531 case EM_CRX:
11532 return reloc_type == 15; /* R_CRX_NUM32. */
11533 case EM_CYGNUS_FRV:
11534 return reloc_type == 1;
11535 case EM_CYGNUS_D10V:
11536 case EM_D10V:
11537 return reloc_type == 6; /* R_D10V_32. */
11538 case EM_CYGNUS_D30V:
11539 case EM_D30V:
11540 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11541 case EM_DLX:
11542 return reloc_type == 3; /* R_DLX_RELOC_32. */
11543 case EM_CYGNUS_FR30:
11544 case EM_FR30:
11545 return reloc_type == 3; /* R_FR30_32. */
11546 case EM_FT32:
11547 return reloc_type == 1; /* R_FT32_32. */
11548 case EM_H8S:
11549 case EM_H8_300:
11550 case EM_H8_300H:
11551 return reloc_type == 1; /* R_H8_DIR32. */
11552 case EM_IA_64:
11553 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11554 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
11555 case EM_IP2K_OLD:
11556 case EM_IP2K:
11557 return reloc_type == 2; /* R_IP2K_32. */
11558 case EM_IQ2000:
11559 return reloc_type == 2; /* R_IQ2000_32. */
11560 case EM_LATTICEMICO32:
11561 return reloc_type == 3; /* R_LM32_32. */
11562 case EM_M32C_OLD:
11563 case EM_M32C:
11564 return reloc_type == 3; /* R_M32C_32. */
11565 case EM_M32R:
11566 return reloc_type == 34; /* R_M32R_32_RELA. */
11567 case EM_68HC11:
11568 case EM_68HC12:
11569 return reloc_type == 6; /* R_M68HC11_32. */
11570 case EM_MCORE:
11571 return reloc_type == 1; /* R_MCORE_ADDR32. */
11572 case EM_CYGNUS_MEP:
11573 return reloc_type == 4; /* R_MEP_32. */
11574 case EM_METAG:
11575 return reloc_type == 2; /* R_METAG_ADDR32. */
11576 case EM_MICROBLAZE:
11577 return reloc_type == 1; /* R_MICROBLAZE_32. */
11578 case EM_MIPS:
11579 return reloc_type == 2; /* R_MIPS_32. */
11580 case EM_MMIX:
11581 return reloc_type == 4; /* R_MMIX_32. */
11582 case EM_CYGNUS_MN10200:
11583 case EM_MN10200:
11584 return reloc_type == 1; /* R_MN10200_32. */
11585 case EM_CYGNUS_MN10300:
11586 case EM_MN10300:
11587 return reloc_type == 1; /* R_MN10300_32. */
11588 case EM_MOXIE:
11589 return reloc_type == 1; /* R_MOXIE_32. */
11590 case EM_MSP430_OLD:
11591 case EM_MSP430:
11592 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11593 case EM_MT:
11594 return reloc_type == 2; /* R_MT_32. */
11595 case EM_NDS32:
11596 return reloc_type == 20; /* R_NDS32_RELA. */
11597 case EM_ALTERA_NIOS2:
11598 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
11599 case EM_NIOS32:
11600 return reloc_type == 1; /* R_NIOS_32. */
11601 case EM_OR1K:
11602 return reloc_type == 1; /* R_OR1K_32. */
11603 case EM_PARISC:
11604 return (reloc_type == 1 /* R_PARISC_DIR32. */
11605 || reloc_type == 41); /* R_PARISC_SECREL32. */
11606 case EM_PJ:
11607 case EM_PJ_OLD:
11608 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11609 case EM_PPC64:
11610 return reloc_type == 1; /* R_PPC64_ADDR32. */
11611 case EM_PPC:
11612 return reloc_type == 1; /* R_PPC_ADDR32. */
11613 case EM_RL78:
11614 return reloc_type == 1; /* R_RL78_DIR32. */
11615 case EM_RX:
11616 return reloc_type == 1; /* R_RX_DIR32. */
11617 case EM_S370:
11618 return reloc_type == 1; /* R_I370_ADDR31. */
11619 case EM_S390_OLD:
11620 case EM_S390:
11621 return reloc_type == 4; /* R_S390_32. */
11622 case EM_SCORE:
11623 return reloc_type == 8; /* R_SCORE_ABS32. */
11624 case EM_SH:
11625 return reloc_type == 1; /* R_SH_DIR32. */
11626 case EM_SPARC32PLUS:
11627 case EM_SPARCV9:
11628 case EM_SPARC:
11629 return reloc_type == 3 /* R_SPARC_32. */
11630 || reloc_type == 23; /* R_SPARC_UA32. */
11631 case EM_SPU:
11632 return reloc_type == 6; /* R_SPU_ADDR32 */
11633 case EM_TI_C6000:
11634 return reloc_type == 1; /* R_C6000_ABS32. */
11635 case EM_TILEGX:
11636 return reloc_type == 2; /* R_TILEGX_32. */
11637 case EM_TILEPRO:
11638 return reloc_type == 1; /* R_TILEPRO_32. */
11639 case EM_CYGNUS_V850:
11640 case EM_V850:
11641 return reloc_type == 6; /* R_V850_ABS32. */
11642 case EM_V800:
11643 return reloc_type == 0x33; /* R_V810_WORD. */
11644 case EM_VAX:
11645 return reloc_type == 1; /* R_VAX_32. */
11646 case EM_VISIUM:
11647 return reloc_type == 3; /* R_VISIUM_32. */
11648 case EM_X86_64:
11649 case EM_L1OM:
11650 case EM_K1OM:
11651 return reloc_type == 10; /* R_X86_64_32. */
11652 case EM_XC16X:
11653 case EM_C166:
11654 return reloc_type == 3; /* R_XC16C_ABS_32. */
11655 case EM_XGATE:
11656 return reloc_type == 4; /* R_XGATE_32. */
11657 case EM_XSTORMY16:
11658 return reloc_type == 1; /* R_XSTROMY16_32. */
11659 case EM_XTENSA_OLD:
11660 case EM_XTENSA:
11661 return reloc_type == 1; /* R_XTENSA_32. */
11662 default:
11663 {
11664 static unsigned int prev_warn = 0;
11665
11666 /* Avoid repeating the same warning multiple times. */
11667 if (prev_warn != elf_header.e_machine)
11668 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11669 elf_header.e_machine);
11670 prev_warn = elf_header.e_machine;
11671 return FALSE;
11672 }
11673 }
11674}
11675
11676/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11677 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11678
11679static bfd_boolean
11680is_32bit_pcrel_reloc (unsigned int reloc_type)
11681{
11682 switch (elf_header.e_machine)
11683 /* Please keep this table alpha-sorted for ease of visual lookup. */
11684 {
11685 case EM_386:
11686 case EM_IAMCU:
11687 return reloc_type == 2; /* R_386_PC32. */
11688 case EM_68K:
11689 return reloc_type == 4; /* R_68K_PC32. */
11690 case EM_AARCH64:
11691 return reloc_type == 261; /* R_AARCH64_PREL32 */
11692 case EM_ADAPTEVA_EPIPHANY:
11693 return reloc_type == 6;
11694 case EM_ALPHA:
11695 return reloc_type == 10; /* R_ALPHA_SREL32. */
11696 case EM_ARC_COMPACT:
11697 case EM_ARC_COMPACT2:
11698 return reloc_type == 49; /* R_ARC_32_PCREL. */
11699 case EM_ARM:
11700 return reloc_type == 3; /* R_ARM_REL32 */
11701 case EM_AVR_OLD:
11702 case EM_AVR:
11703 return reloc_type == 36; /* R_AVR_32_PCREL. */
11704 case EM_MICROBLAZE:
11705 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11706 case EM_OR1K:
11707 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11708 case EM_PARISC:
11709 return reloc_type == 9; /* R_PARISC_PCREL32. */
11710 case EM_PPC:
11711 return reloc_type == 26; /* R_PPC_REL32. */
11712 case EM_PPC64:
11713 return reloc_type == 26; /* R_PPC64_REL32. */
11714 case EM_S390_OLD:
11715 case EM_S390:
11716 return reloc_type == 5; /* R_390_PC32. */
11717 case EM_SH:
11718 return reloc_type == 2; /* R_SH_REL32. */
11719 case EM_SPARC32PLUS:
11720 case EM_SPARCV9:
11721 case EM_SPARC:
11722 return reloc_type == 6; /* R_SPARC_DISP32. */
11723 case EM_SPU:
11724 return reloc_type == 13; /* R_SPU_REL32. */
11725 case EM_TILEGX:
11726 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11727 case EM_TILEPRO:
11728 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11729 case EM_VISIUM:
11730 return reloc_type == 6; /* R_VISIUM_32_PCREL */
11731 case EM_X86_64:
11732 case EM_L1OM:
11733 case EM_K1OM:
11734 return reloc_type == 2; /* R_X86_64_PC32. */
11735 case EM_XTENSA_OLD:
11736 case EM_XTENSA:
11737 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11738 default:
11739 /* Do not abort or issue an error message here. Not all targets use
11740 pc-relative 32-bit relocs in their DWARF debug information and we
11741 have already tested for target coverage in is_32bit_abs_reloc. A
11742 more helpful warning message will be generated by apply_relocations
11743 anyway, so just return. */
11744 return FALSE;
11745 }
11746}
11747
11748/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11749 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11750
11751static bfd_boolean
11752is_64bit_abs_reloc (unsigned int reloc_type)
11753{
11754 switch (elf_header.e_machine)
11755 {
11756 case EM_AARCH64:
11757 return reloc_type == 257; /* R_AARCH64_ABS64. */
11758 case EM_ALPHA:
11759 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11760 case EM_IA_64:
11761 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11762 case EM_PARISC:
11763 return reloc_type == 80; /* R_PARISC_DIR64. */
11764 case EM_PPC64:
11765 return reloc_type == 38; /* R_PPC64_ADDR64. */
11766 case EM_SPARC32PLUS:
11767 case EM_SPARCV9:
11768 case EM_SPARC:
11769 return reloc_type == 54; /* R_SPARC_UA64. */
11770 case EM_X86_64:
11771 case EM_L1OM:
11772 case EM_K1OM:
11773 return reloc_type == 1; /* R_X86_64_64. */
11774 case EM_S390_OLD:
11775 case EM_S390:
11776 return reloc_type == 22; /* R_S390_64. */
11777 case EM_TILEGX:
11778 return reloc_type == 1; /* R_TILEGX_64. */
11779 case EM_MIPS:
11780 return reloc_type == 18; /* R_MIPS_64. */
11781 default:
11782 return FALSE;
11783 }
11784}
11785
11786/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11787 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11788
11789static bfd_boolean
11790is_64bit_pcrel_reloc (unsigned int reloc_type)
11791{
11792 switch (elf_header.e_machine)
11793 {
11794 case EM_AARCH64:
11795 return reloc_type == 260; /* R_AARCH64_PREL64. */
11796 case EM_ALPHA:
11797 return reloc_type == 11; /* R_ALPHA_SREL64. */
11798 case EM_IA_64:
11799 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11800 case EM_PARISC:
11801 return reloc_type == 72; /* R_PARISC_PCREL64. */
11802 case EM_PPC64:
11803 return reloc_type == 44; /* R_PPC64_REL64. */
11804 case EM_SPARC32PLUS:
11805 case EM_SPARCV9:
11806 case EM_SPARC:
11807 return reloc_type == 46; /* R_SPARC_DISP64. */
11808 case EM_X86_64:
11809 case EM_L1OM:
11810 case EM_K1OM:
11811 return reloc_type == 24; /* R_X86_64_PC64. */
11812 case EM_S390_OLD:
11813 case EM_S390:
11814 return reloc_type == 23; /* R_S390_PC64. */
11815 case EM_TILEGX:
11816 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11817 default:
11818 return FALSE;
11819 }
11820}
11821
11822/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11823 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11824
11825static bfd_boolean
11826is_24bit_abs_reloc (unsigned int reloc_type)
11827{
11828 switch (elf_header.e_machine)
11829 {
11830 case EM_CYGNUS_MN10200:
11831 case EM_MN10200:
11832 return reloc_type == 4; /* R_MN10200_24. */
11833 case EM_FT32:
11834 return reloc_type == 5; /* R_FT32_20. */
11835 default:
11836 return FALSE;
11837 }
11838}
11839
11840/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11841 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11842
11843static bfd_boolean
11844is_16bit_abs_reloc (unsigned int reloc_type)
11845{
11846 /* Please keep this table alpha-sorted for ease of visual lookup. */
11847 switch (elf_header.e_machine)
11848 {
11849 case EM_ARC:
11850 case EM_ARC_COMPACT:
11851 case EM_ARC_COMPACT2:
11852 return reloc_type == 2; /* R_ARC_16. */
11853 case EM_ADAPTEVA_EPIPHANY:
11854 return reloc_type == 5;
11855 case EM_AVR_OLD:
11856 case EM_AVR:
11857 return reloc_type == 4; /* R_AVR_16. */
11858 case EM_CYGNUS_D10V:
11859 case EM_D10V:
11860 return reloc_type == 3; /* R_D10V_16. */
11861 case EM_H8S:
11862 case EM_H8_300:
11863 case EM_H8_300H:
11864 return reloc_type == R_H8_DIR16;
11865 case EM_IP2K_OLD:
11866 case EM_IP2K:
11867 return reloc_type == 1; /* R_IP2K_16. */
11868 case EM_M32C_OLD:
11869 case EM_M32C:
11870 return reloc_type == 1; /* R_M32C_16 */
11871 case EM_CYGNUS_MN10200:
11872 case EM_MN10200:
11873 return reloc_type == 2; /* R_MN10200_16. */
11874 case EM_CYGNUS_MN10300:
11875 case EM_MN10300:
11876 return reloc_type == 2; /* R_MN10300_16. */
11877 case EM_MSP430:
11878 if (uses_msp430x_relocs ())
11879 return reloc_type == 2; /* R_MSP430_ABS16. */
11880 case EM_MSP430_OLD:
11881 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11882 case EM_NDS32:
11883 return reloc_type == 19; /* R_NDS32_RELA. */
11884 case EM_ALTERA_NIOS2:
11885 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11886 case EM_NIOS32:
11887 return reloc_type == 9; /* R_NIOS_16. */
11888 case EM_OR1K:
11889 return reloc_type == 2; /* R_OR1K_16. */
11890 case EM_TI_C6000:
11891 return reloc_type == 2; /* R_C6000_ABS16. */
11892 case EM_VISIUM:
11893 return reloc_type == 2; /* R_VISIUM_16. */
11894 case EM_XC16X:
11895 case EM_C166:
11896 return reloc_type == 2; /* R_XC16C_ABS_16. */
11897 case EM_XGATE:
11898 return reloc_type == 3; /* R_XGATE_16. */
11899 default:
11900 return FALSE;
11901 }
11902}
11903
11904/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11905 relocation entries (possibly formerly used for SHT_GROUP sections). */
11906
11907static bfd_boolean
11908is_none_reloc (unsigned int reloc_type)
11909{
11910 switch (elf_header.e_machine)
11911 {
11912 case EM_386: /* R_386_NONE. */
11913 case EM_68K: /* R_68K_NONE. */
11914 case EM_ADAPTEVA_EPIPHANY:
11915 case EM_ALPHA: /* R_ALPHA_NONE. */
11916 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11917 case EM_ARC: /* R_ARC_NONE. */
11918 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
11919 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11920 case EM_ARM: /* R_ARM_NONE. */
11921 case EM_C166: /* R_XC16X_NONE. */
11922 case EM_CRIS: /* R_CRIS_NONE. */
11923 case EM_FT32: /* R_FT32_NONE. */
11924 case EM_IA_64: /* R_IA64_NONE. */
11925 case EM_K1OM: /* R_X86_64_NONE. */
11926 case EM_L1OM: /* R_X86_64_NONE. */
11927 case EM_M32R: /* R_M32R_NONE. */
11928 case EM_MIPS: /* R_MIPS_NONE. */
11929 case EM_MN10300: /* R_MN10300_NONE. */
11930 case EM_MOXIE: /* R_MOXIE_NONE. */
11931 case EM_NIOS32: /* R_NIOS_NONE. */
11932 case EM_OR1K: /* R_OR1K_NONE. */
11933 case EM_PARISC: /* R_PARISC_NONE. */
11934 case EM_PPC64: /* R_PPC64_NONE. */
11935 case EM_PPC: /* R_PPC_NONE. */
11936 case EM_S390: /* R_390_NONE. */
11937 case EM_S390_OLD:
11938 case EM_SH: /* R_SH_NONE. */
11939 case EM_SPARC32PLUS:
11940 case EM_SPARC: /* R_SPARC_NONE. */
11941 case EM_SPARCV9:
11942 case EM_TILEGX: /* R_TILEGX_NONE. */
11943 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11944 case EM_TI_C6000:/* R_C6000_NONE. */
11945 case EM_X86_64: /* R_X86_64_NONE. */
11946 case EM_XC16X:
11947 return reloc_type == 0;
11948
11949 case EM_AARCH64:
11950 return reloc_type == 0 || reloc_type == 256;
11951 case EM_AVR_OLD:
11952 case EM_AVR:
11953 return (reloc_type == 0 /* R_AVR_NONE. */
11954 || reloc_type == 30 /* R_AVR_DIFF8. */
11955 || reloc_type == 31 /* R_AVR_DIFF16. */
11956 || reloc_type == 32 /* R_AVR_DIFF32. */);
11957 case EM_METAG:
11958 return reloc_type == 3; /* R_METAG_NONE. */
11959 case EM_NDS32:
11960 return (reloc_type == 0 /* R_XTENSA_NONE. */
11961 || reloc_type == 204 /* R_NDS32_DIFF8. */
11962 || reloc_type == 205 /* R_NDS32_DIFF16. */
11963 || reloc_type == 206 /* R_NDS32_DIFF32. */
11964 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11965 case EM_XTENSA_OLD:
11966 case EM_XTENSA:
11967 return (reloc_type == 0 /* R_XTENSA_NONE. */
11968 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11969 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11970 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11971 }
11972 return FALSE;
11973}
11974
11975/* Returns TRUE if there is a relocation against
11976 section NAME at OFFSET bytes. */
11977
11978bfd_boolean
11979reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11980{
11981 Elf_Internal_Rela * relocs;
11982 Elf_Internal_Rela * rp;
11983
11984 if (dsec == NULL || dsec->reloc_info == NULL)
11985 return FALSE;
11986
11987 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11988
11989 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11990 if (rp->r_offset == offset)
11991 return TRUE;
11992
11993 return FALSE;
11994}
11995
11996/* Apply relocations to a section.
11997 Note: So far support has been added only for those relocations
11998 which can be found in debug sections.
11999 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12000 loaded relocs. It is then the caller's responsibility to free them.
12001 FIXME: Add support for more relocations ? */
12002
12003static void
12004apply_relocations (void * file,
12005 const Elf_Internal_Shdr * section,
12006 unsigned char * start,
12007 bfd_size_type size,
12008 void ** relocs_return,
12009 unsigned long * num_relocs_return)
12010{
12011 Elf_Internal_Shdr * relsec;
12012 unsigned char * end = start + size;
12013
12014 if (relocs_return != NULL)
12015 {
12016 * (Elf_Internal_Rela **) relocs_return = NULL;
12017 * num_relocs_return = 0;
12018 }
12019
12020 if (elf_header.e_type != ET_REL)
12021 return;
12022
12023 /* Find the reloc section associated with the section. */
12024 for (relsec = section_headers;
12025 relsec < section_headers + elf_header.e_shnum;
12026 ++relsec)
12027 {
12028 bfd_boolean is_rela;
12029 unsigned long num_relocs;
12030 Elf_Internal_Rela * relocs;
12031 Elf_Internal_Rela * rp;
12032 Elf_Internal_Shdr * symsec;
12033 Elf_Internal_Sym * symtab;
12034 unsigned long num_syms;
12035 Elf_Internal_Sym * sym;
12036
12037 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12038 || relsec->sh_info >= elf_header.e_shnum
12039 || section_headers + relsec->sh_info != section
12040 || relsec->sh_size == 0
12041 || relsec->sh_link >= elf_header.e_shnum)
12042 continue;
12043
12044 is_rela = relsec->sh_type == SHT_RELA;
12045
12046 if (is_rela)
12047 {
12048 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12049 relsec->sh_size, & relocs, & num_relocs))
12050 return;
12051 }
12052 else
12053 {
12054 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12055 relsec->sh_size, & relocs, & num_relocs))
12056 return;
12057 }
12058
12059 /* SH uses RELA but uses in place value instead of the addend field. */
12060 if (elf_header.e_machine == EM_SH)
12061 is_rela = FALSE;
12062
12063 symsec = section_headers + relsec->sh_link;
12064 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12065
12066 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12067 {
12068 bfd_vma addend;
12069 unsigned int reloc_type;
12070 unsigned int reloc_size;
12071 unsigned char * rloc;
12072 unsigned long sym_index;
12073
12074 reloc_type = get_reloc_type (rp->r_info);
12075
12076 if (target_specific_reloc_handling (rp, start, symtab))
12077 continue;
12078 else if (is_none_reloc (reloc_type))
12079 continue;
12080 else if (is_32bit_abs_reloc (reloc_type)
12081 || is_32bit_pcrel_reloc (reloc_type))
12082 reloc_size = 4;
12083 else if (is_64bit_abs_reloc (reloc_type)
12084 || is_64bit_pcrel_reloc (reloc_type))
12085 reloc_size = 8;
12086 else if (is_24bit_abs_reloc (reloc_type))
12087 reloc_size = 3;
12088 else if (is_16bit_abs_reloc (reloc_type))
12089 reloc_size = 2;
12090 else
12091 {
12092 static unsigned int prev_reloc = 0;
12093 if (reloc_type != prev_reloc)
12094 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12095 reloc_type, printable_section_name (section));
12096 prev_reloc = reloc_type;
12097 continue;
12098 }
12099
12100 rloc = start + rp->r_offset;
12101 if ((rloc + reloc_size) > end || (rloc < start))
12102 {
12103 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12104 (unsigned long) rp->r_offset,
12105 printable_section_name (section));
12106 continue;
12107 }
12108
12109 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12110 if (sym_index >= num_syms)
12111 {
12112 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12113 sym_index, printable_section_name (section));
12114 continue;
12115 }
12116 sym = symtab + sym_index;
12117
12118 /* If the reloc has a symbol associated with it,
12119 make sure that it is of an appropriate type.
12120
12121 Relocations against symbols without type can happen.
12122 Gcc -feliminate-dwarf2-dups may generate symbols
12123 without type for debug info.
12124
12125 Icc generates relocations against function symbols
12126 instead of local labels.
12127
12128 Relocations against object symbols can happen, eg when
12129 referencing a global array. For an example of this see
12130 the _clz.o binary in libgcc.a. */
12131 if (sym != symtab
12132 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12133 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12134 {
12135 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12136 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12137 (long int)(rp - relocs),
12138 printable_section_name (relsec));
12139 continue;
12140 }
12141
12142 addend = 0;
12143 if (is_rela)
12144 addend += rp->r_addend;
12145 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12146 partial_inplace. */
12147 if (!is_rela
12148 || (elf_header.e_machine == EM_XTENSA
12149 && reloc_type == 1)
12150 || ((elf_header.e_machine == EM_PJ
12151 || elf_header.e_machine == EM_PJ_OLD)
12152 && reloc_type == 1)
12153 || ((elf_header.e_machine == EM_D30V
12154 || elf_header.e_machine == EM_CYGNUS_D30V)
12155 && reloc_type == 12))
12156 addend += byte_get (rloc, reloc_size);
12157
12158 if (is_32bit_pcrel_reloc (reloc_type)
12159 || is_64bit_pcrel_reloc (reloc_type))
12160 {
12161 /* On HPPA, all pc-relative relocations are biased by 8. */
12162 if (elf_header.e_machine == EM_PARISC)
12163 addend -= 8;
12164 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12165 reloc_size);
12166 }
12167 else
12168 byte_put (rloc, addend + sym->st_value, reloc_size);
12169 }
12170
12171 free (symtab);
12172
12173 if (relocs_return)
12174 {
12175 * (Elf_Internal_Rela **) relocs_return = relocs;
12176 * num_relocs_return = num_relocs;
12177 }
12178 else
12179 free (relocs);
12180
12181 break;
12182 }
12183}
12184
12185#ifdef SUPPORT_DISASSEMBLY
12186static int
12187disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12188{
12189 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12190
12191 /* FIXME: XXX -- to be done --- XXX */
12192
12193 return 1;
12194}
12195#endif
12196
12197/* Reads in the contents of SECTION from FILE, returning a pointer
12198 to a malloc'ed buffer or NULL if something went wrong. */
12199
12200static char *
12201get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12202{
12203 bfd_size_type num_bytes;
12204
12205 num_bytes = section->sh_size;
12206
12207 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12208 {
12209 printf (_("\nSection '%s' has no data to dump.\n"),
12210 printable_section_name (section));
12211 return NULL;
12212 }
12213
12214 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12215 _("section contents"));
12216}
12217
12218/* Uncompresses a section that was compressed using zlib, in place. */
12219
12220static bfd_boolean
12221uncompress_section_contents (unsigned char **buffer,
12222 dwarf_size_type uncompressed_size,
12223 dwarf_size_type *size)
12224{
12225 dwarf_size_type compressed_size = *size;
12226 unsigned char * compressed_buffer = *buffer;
12227 unsigned char * uncompressed_buffer;
12228 z_stream strm;
12229 int rc;
12230
12231 /* It is possible the section consists of several compressed
12232 buffers concatenated together, so we uncompress in a loop. */
12233 /* PR 18313: The state field in the z_stream structure is supposed
12234 to be invisible to the user (ie us), but some compilers will
12235 still complain about it being used without initialisation. So
12236 we first zero the entire z_stream structure and then set the fields
12237 that we need. */
12238 memset (& strm, 0, sizeof strm);
12239 strm.avail_in = compressed_size;
12240 strm.next_in = (Bytef *) compressed_buffer;
12241 strm.avail_out = uncompressed_size;
12242 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12243
12244 rc = inflateInit (& strm);
12245 while (strm.avail_in > 0)
12246 {
12247 if (rc != Z_OK)
12248 goto fail;
12249 strm.next_out = ((Bytef *) uncompressed_buffer
12250 + (uncompressed_size - strm.avail_out));
12251 rc = inflate (&strm, Z_FINISH);
12252 if (rc != Z_STREAM_END)
12253 goto fail;
12254 rc = inflateReset (& strm);
12255 }
12256 rc = inflateEnd (& strm);
12257 if (rc != Z_OK
12258 || strm.avail_out != 0)
12259 goto fail;
12260
12261 *buffer = uncompressed_buffer;
12262 *size = uncompressed_size;
12263 return TRUE;
12264
12265 fail:
12266 free (uncompressed_buffer);
12267 /* Indicate decompression failure. */
12268 *buffer = NULL;
12269 return FALSE;
12270}
12271
12272static void
12273dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12274{
12275 Elf_Internal_Shdr * relsec;
12276 bfd_size_type num_bytes;
12277 unsigned char * data;
12278 unsigned char * end;
12279 unsigned char * real_start;
12280 unsigned char * start;
12281 bfd_boolean some_strings_shown;
12282
12283 real_start = start = (unsigned char *) get_section_contents (section,
12284 file);
12285 if (start == NULL)
12286 return;
12287 num_bytes = section->sh_size;
12288
12289 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12290
12291 if (decompress_dumps)
12292 {
12293 dwarf_size_type new_size = num_bytes;
12294 dwarf_size_type uncompressed_size = 0;
12295
12296 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12297 {
12298 Elf_Internal_Chdr chdr;
12299 unsigned int compression_header_size
12300 = get_compression_header (& chdr, (unsigned char *) start);
12301
12302 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12303 {
12304 warn (_("section '%s' has unsupported compress type: %d\n"),
12305 printable_section_name (section), chdr.ch_type);
12306 return;
12307 }
12308 else if (chdr.ch_addralign != section->sh_addralign)
12309 {
12310 warn (_("compressed section '%s' is corrupted\n"),
12311 printable_section_name (section));
12312 return;
12313 }
12314 uncompressed_size = chdr.ch_size;
12315 start += compression_header_size;
12316 new_size -= compression_header_size;
12317 }
12318 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12319 {
12320 /* Read the zlib header. In this case, it should be "ZLIB"
12321 followed by the uncompressed section size, 8 bytes in
12322 big-endian order. */
12323 uncompressed_size = start[4]; uncompressed_size <<= 8;
12324 uncompressed_size += start[5]; uncompressed_size <<= 8;
12325 uncompressed_size += start[6]; uncompressed_size <<= 8;
12326 uncompressed_size += start[7]; uncompressed_size <<= 8;
12327 uncompressed_size += start[8]; uncompressed_size <<= 8;
12328 uncompressed_size += start[9]; uncompressed_size <<= 8;
12329 uncompressed_size += start[10]; uncompressed_size <<= 8;
12330 uncompressed_size += start[11];
12331 start += 12;
12332 new_size -= 12;
12333 }
12334
12335 if (uncompressed_size
12336 && uncompress_section_contents (& start,
12337 uncompressed_size, & new_size))
12338 num_bytes = new_size;
12339 }
12340
12341 /* If the section being dumped has relocations against it the user might
12342 be expecting these relocations to have been applied. Check for this
12343 case and issue a warning message in order to avoid confusion.
12344 FIXME: Maybe we ought to have an option that dumps a section with
12345 relocs applied ? */
12346 for (relsec = section_headers;
12347 relsec < section_headers + elf_header.e_shnum;
12348 ++relsec)
12349 {
12350 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12351 || relsec->sh_info >= elf_header.e_shnum
12352 || section_headers + relsec->sh_info != section
12353 || relsec->sh_size == 0
12354 || relsec->sh_link >= elf_header.e_shnum)
12355 continue;
12356
12357 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12358 break;
12359 }
12360
12361 data = start;
12362 end = start + num_bytes;
12363 some_strings_shown = FALSE;
12364
12365 while (data < end)
12366 {
12367 while (!ISPRINT (* data))
12368 if (++ data >= end)
12369 break;
12370
12371 if (data < end)
12372 {
12373 size_t maxlen = end - data;
12374
12375#ifndef __MSVCRT__
12376 /* PR 11128: Use two separate invocations in order to work
12377 around bugs in the Solaris 8 implementation of printf. */
12378 printf (" [%6tx] ", data - start);
12379#else
12380 printf (" [%6Ix] ", (size_t) (data - start));
12381#endif
12382 if (maxlen > 0)
12383 {
12384 print_symbol ((int) maxlen, (const char *) data);
12385 putchar ('\n');
12386 data += strnlen ((const char *) data, maxlen);
12387 }
12388 else
12389 {
12390 printf (_("<corrupt>\n"));
12391 data = end;
12392 }
12393 some_strings_shown = TRUE;
12394 }
12395 }
12396
12397 if (! some_strings_shown)
12398 printf (_(" No strings found in this section."));
12399
12400 free (real_start);
12401
12402 putchar ('\n');
12403}
12404
12405static void
12406dump_section_as_bytes (Elf_Internal_Shdr * section,
12407 FILE * file,
12408 bfd_boolean relocate)
12409{
12410 Elf_Internal_Shdr * relsec;
12411 bfd_size_type bytes;
12412 bfd_size_type section_size;
12413 bfd_vma addr;
12414 unsigned char * data;
12415 unsigned char * real_start;
12416 unsigned char * start;
12417
12418 real_start = start = (unsigned char *) get_section_contents (section, file);
12419 if (start == NULL)
12420 return;
12421 section_size = section->sh_size;
12422
12423 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12424
12425 if (decompress_dumps)
12426 {
12427 dwarf_size_type new_size = section_size;
12428 dwarf_size_type uncompressed_size = 0;
12429
12430 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12431 {
12432 Elf_Internal_Chdr chdr;
12433 unsigned int compression_header_size
12434 = get_compression_header (& chdr, start);
12435
12436 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12437 {
12438 warn (_("section '%s' has unsupported compress type: %d\n"),
12439 printable_section_name (section), chdr.ch_type);
12440 return;
12441 }
12442 else if (chdr.ch_addralign != section->sh_addralign)
12443 {
12444 warn (_("compressed section '%s' is corrupted\n"),
12445 printable_section_name (section));
12446 return;
12447 }
12448 uncompressed_size = chdr.ch_size;
12449 start += compression_header_size;
12450 new_size -= compression_header_size;
12451 }
12452 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12453 {
12454 /* Read the zlib header. In this case, it should be "ZLIB"
12455 followed by the uncompressed section size, 8 bytes in
12456 big-endian order. */
12457 uncompressed_size = start[4]; uncompressed_size <<= 8;
12458 uncompressed_size += start[5]; uncompressed_size <<= 8;
12459 uncompressed_size += start[6]; uncompressed_size <<= 8;
12460 uncompressed_size += start[7]; uncompressed_size <<= 8;
12461 uncompressed_size += start[8]; uncompressed_size <<= 8;
12462 uncompressed_size += start[9]; uncompressed_size <<= 8;
12463 uncompressed_size += start[10]; uncompressed_size <<= 8;
12464 uncompressed_size += start[11];
12465 start += 12;
12466 new_size -= 12;
12467 }
12468
12469 if (uncompressed_size
12470 && uncompress_section_contents (& start, uncompressed_size,
12471 & new_size))
12472 section_size = new_size;
12473 }
12474
12475 if (relocate)
12476 {
12477 apply_relocations (file, section, start, section_size, NULL, NULL);
12478 }
12479 else
12480 {
12481 /* If the section being dumped has relocations against it the user might
12482 be expecting these relocations to have been applied. Check for this
12483 case and issue a warning message in order to avoid confusion.
12484 FIXME: Maybe we ought to have an option that dumps a section with
12485 relocs applied ? */
12486 for (relsec = section_headers;
12487 relsec < section_headers + elf_header.e_shnum;
12488 ++relsec)
12489 {
12490 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12491 || relsec->sh_info >= elf_header.e_shnum
12492 || section_headers + relsec->sh_info != section
12493 || relsec->sh_size == 0
12494 || relsec->sh_link >= elf_header.e_shnum)
12495 continue;
12496
12497 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12498 break;
12499 }
12500 }
12501
12502 addr = section->sh_addr;
12503 bytes = section_size;
12504 data = start;
12505
12506 while (bytes)
12507 {
12508 int j;
12509 int k;
12510 int lbytes;
12511
12512 lbytes = (bytes > 16 ? 16 : bytes);
12513
12514 printf (" 0x%8.8lx ", (unsigned long) addr);
12515
12516 for (j = 0; j < 16; j++)
12517 {
12518 if (j < lbytes)
12519 printf ("%2.2x", data[j]);
12520 else
12521 printf (" ");
12522
12523 if ((j & 3) == 3)
12524 printf (" ");
12525 }
12526
12527 for (j = 0; j < lbytes; j++)
12528 {
12529 k = data[j];
12530 if (k >= ' ' && k < 0x7f)
12531 printf ("%c", k);
12532 else
12533 printf (".");
12534 }
12535
12536 putchar ('\n');
12537
12538 data += lbytes;
12539 addr += lbytes;
12540 bytes -= lbytes;
12541 }
12542
12543 free (real_start);
12544
12545 putchar ('\n');
12546}
12547
12548static int
12549load_specific_debug_section (enum dwarf_section_display_enum debug,
12550 const Elf_Internal_Shdr * sec, void * file)
12551{
12552 struct dwarf_section * section = &debug_displays [debug].section;
12553 char buf [64];
12554
12555 /* If it is already loaded, do nothing. */
12556 if (section->start != NULL)
12557 return 1;
12558
12559 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12560 section->address = sec->sh_addr;
12561 section->user_data = NULL;
12562 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12563 sec->sh_offset, 1,
12564 sec->sh_size, buf);
12565 if (section->start == NULL)
12566 section->size = 0;
12567 else
12568 {
12569 unsigned char *start = section->start;
12570 dwarf_size_type size = sec->sh_size;
12571 dwarf_size_type uncompressed_size = 0;
12572
12573 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12574 {
12575 Elf_Internal_Chdr chdr;
12576 unsigned int compression_header_size
12577 = get_compression_header (&chdr, start);
12578 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12579 {
12580 warn (_("section '%s' has unsupported compress type: %d\n"),
12581 section->name, chdr.ch_type);
12582 return 0;
12583 }
12584 else if (chdr.ch_addralign != sec->sh_addralign)
12585 {
12586 warn (_("compressed section '%s' is corrupted\n"),
12587 section->name);
12588 return 0;
12589 }
12590 uncompressed_size = chdr.ch_size;
12591 start += compression_header_size;
12592 size -= compression_header_size;
12593 }
12594 else if (size > 12 && streq ((char *) start, "ZLIB"))
12595 {
12596 /* Read the zlib header. In this case, it should be "ZLIB"
12597 followed by the uncompressed section size, 8 bytes in
12598 big-endian order. */
12599 uncompressed_size = start[4]; uncompressed_size <<= 8;
12600 uncompressed_size += start[5]; uncompressed_size <<= 8;
12601 uncompressed_size += start[6]; uncompressed_size <<= 8;
12602 uncompressed_size += start[7]; uncompressed_size <<= 8;
12603 uncompressed_size += start[8]; uncompressed_size <<= 8;
12604 uncompressed_size += start[9]; uncompressed_size <<= 8;
12605 uncompressed_size += start[10]; uncompressed_size <<= 8;
12606 uncompressed_size += start[11];
12607 start += 12;
12608 size -= 12;
12609 }
12610
12611 if (uncompressed_size
12612 && uncompress_section_contents (&start, uncompressed_size,
12613 &size))
12614 {
12615 /* Free the compressed buffer, update the section buffer
12616 and the section size if uncompress is successful. */
12617 free (section->start);
12618 section->start = start;
12619 }
12620 section->size = size;
12621 }
12622
12623 if (section->start == NULL)
12624 return 0;
12625
12626 if (debug_displays [debug].relocate)
12627 apply_relocations ((FILE *) file, sec, section->start, section->size,
12628 & section->reloc_info, & section->num_relocs);
12629 else
12630 {
12631 section->reloc_info = NULL;
12632 section->num_relocs = 0;
12633 }
12634
12635 return 1;
12636}
12637
12638/* If this is not NULL, load_debug_section will only look for sections
12639 within the list of sections given here. */
12640unsigned int *section_subset = NULL;
12641
12642int
12643load_debug_section (enum dwarf_section_display_enum debug, void * file)
12644{
12645 struct dwarf_section * section = &debug_displays [debug].section;
12646 Elf_Internal_Shdr * sec;
12647
12648 /* Locate the debug section. */
12649 sec = find_section_in_set (section->uncompressed_name, section_subset);
12650 if (sec != NULL)
12651 section->name = section->uncompressed_name;
12652 else
12653 {
12654 sec = find_section_in_set (section->compressed_name, section_subset);
12655 if (sec != NULL)
12656 section->name = section->compressed_name;
12657 }
12658 if (sec == NULL)
12659 return 0;
12660
12661 /* If we're loading from a subset of sections, and we've loaded
12662 a section matching this name before, it's likely that it's a
12663 different one. */
12664 if (section_subset != NULL)
12665 free_debug_section (debug);
12666
12667 return load_specific_debug_section (debug, sec, (FILE *) file);
12668}
12669
12670void
12671free_debug_section (enum dwarf_section_display_enum debug)
12672{
12673 struct dwarf_section * section = &debug_displays [debug].section;
12674
12675 if (section->start == NULL)
12676 return;
12677
12678 free ((char *) section->start);
12679 section->start = NULL;
12680 section->address = 0;
12681 section->size = 0;
12682}
12683
12684static int
12685display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12686{
12687 char * name = SECTION_NAME (section);
12688 const char * print_name = printable_section_name (section);
12689 bfd_size_type length;
12690 int result = 1;
12691 int i;
12692
12693 length = section->sh_size;
12694 if (length == 0)
12695 {
12696 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12697 return 0;
12698 }
12699 if (section->sh_type == SHT_NOBITS)
12700 {
12701 /* There is no point in dumping the contents of a debugging section
12702 which has the NOBITS type - the bits in the file will be random.
12703 This can happen when a file containing a .eh_frame section is
12704 stripped with the --only-keep-debug command line option. */
12705 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12706 print_name);
12707 return 0;
12708 }
12709
12710 if (const_strneq (name, ".gnu.linkonce.wi."))
12711 name = ".debug_info";
12712
12713 /* See if we know how to display the contents of this section. */
12714 for (i = 0; i < max; i++)
12715 if (streq (debug_displays[i].section.uncompressed_name, name)
12716 || (i == line && const_strneq (name, ".debug_line."))
12717 || streq (debug_displays[i].section.compressed_name, name))
12718 {
12719 struct dwarf_section * sec = &debug_displays [i].section;
12720 int secondary = (section != find_section (name));
12721
12722 if (secondary)
12723 free_debug_section ((enum dwarf_section_display_enum) i);
12724
12725 if (i == line && const_strneq (name, ".debug_line."))
12726 sec->name = name;
12727 else if (streq (sec->uncompressed_name, name))
12728 sec->name = sec->uncompressed_name;
12729 else
12730 sec->name = sec->compressed_name;
12731 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12732 section, file))
12733 {
12734 /* If this debug section is part of a CU/TU set in a .dwp file,
12735 restrict load_debug_section to the sections in that set. */
12736 section_subset = find_cu_tu_set (file, shndx);
12737
12738 result &= debug_displays[i].display (sec, file);
12739
12740 section_subset = NULL;
12741
12742 if (secondary || (i != info && i != abbrev))
12743 free_debug_section ((enum dwarf_section_display_enum) i);
12744 }
12745
12746 break;
12747 }
12748
12749 if (i == max)
12750 {
12751 printf (_("Unrecognized debug section: %s\n"), print_name);
12752 result = 0;
12753 }
12754
12755 return result;
12756}
12757
12758/* Set DUMP_SECTS for all sections where dumps were requested
12759 based on section name. */
12760
12761static void
12762initialise_dumps_byname (void)
12763{
12764 struct dump_list_entry * cur;
12765
12766 for (cur = dump_sects_byname; cur; cur = cur->next)
12767 {
12768 unsigned int i;
12769 int any;
12770
12771 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12772 if (streq (SECTION_NAME (section_headers + i), cur->name))
12773 {
12774 request_dump_bynumber (i, cur->type);
12775 any = 1;
12776 }
12777
12778 if (!any)
12779 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12780 cur->name);
12781 }
12782}
12783
12784static void
12785process_section_contents (FILE * file)
12786{
12787 Elf_Internal_Shdr * section;
12788 unsigned int i;
12789
12790 if (! do_dump)
12791 return;
12792
12793 initialise_dumps_byname ();
12794
12795 for (i = 0, section = section_headers;
12796 i < elf_header.e_shnum && i < num_dump_sects;
12797 i++, section++)
12798 {
12799#ifdef SUPPORT_DISASSEMBLY
12800 if (dump_sects[i] & DISASS_DUMP)
12801 disassemble_section (section, file);
12802#endif
12803 if (dump_sects[i] & HEX_DUMP)
12804 dump_section_as_bytes (section, file, FALSE);
12805
12806 if (dump_sects[i] & RELOC_DUMP)
12807 dump_section_as_bytes (section, file, TRUE);
12808
12809 if (dump_sects[i] & STRING_DUMP)
12810 dump_section_as_strings (section, file);
12811
12812 if (dump_sects[i] & DEBUG_DUMP)
12813 display_debug_section (i, section, file);
12814 }
12815
12816 /* Check to see if the user requested a
12817 dump of a section that does not exist. */
12818 while (i++ < num_dump_sects)
12819 if (dump_sects[i])
12820 warn (_("Section %d was not dumped because it does not exist!\n"), i);
12821}
12822
12823static void
12824process_mips_fpe_exception (int mask)
12825{
12826 if (mask)
12827 {
12828 int first = 1;
12829 if (mask & OEX_FPU_INEX)
12830 fputs ("INEX", stdout), first = 0;
12831 if (mask & OEX_FPU_UFLO)
12832 printf ("%sUFLO", first ? "" : "|"), first = 0;
12833 if (mask & OEX_FPU_OFLO)
12834 printf ("%sOFLO", first ? "" : "|"), first = 0;
12835 if (mask & OEX_FPU_DIV0)
12836 printf ("%sDIV0", first ? "" : "|"), first = 0;
12837 if (mask & OEX_FPU_INVAL)
12838 printf ("%sINVAL", first ? "" : "|");
12839 }
12840 else
12841 fputs ("0", stdout);
12842}
12843
12844/* Display's the value of TAG at location P. If TAG is
12845 greater than 0 it is assumed to be an unknown tag, and
12846 a message is printed to this effect. Otherwise it is
12847 assumed that a message has already been printed.
12848
12849 If the bottom bit of TAG is set it assumed to have a
12850 string value, otherwise it is assumed to have an integer
12851 value.
12852
12853 Returns an updated P pointing to the first unread byte
12854 beyond the end of TAG's value.
12855
12856 Reads at or beyond END will not be made. */
12857
12858static unsigned char *
12859display_tag_value (int tag,
12860 unsigned char * p,
12861 const unsigned char * const end)
12862{
12863 unsigned long val;
12864
12865 if (tag > 0)
12866 printf (" Tag_unknown_%d: ", tag);
12867
12868 if (p >= end)
12869 {
12870 warn (_("<corrupt tag>\n"));
12871 }
12872 else if (tag & 1)
12873 {
12874 /* PR 17531 file: 027-19978-0.004. */
12875 size_t maxlen = (end - p) - 1;
12876
12877 putchar ('"');
12878 if (maxlen > 0)
12879 {
12880 print_symbol ((int) maxlen, (const char *) p);
12881 p += strnlen ((char *) p, maxlen) + 1;
12882 }
12883 else
12884 {
12885 printf (_("<corrupt string tag>"));
12886 p = (unsigned char *) end;
12887 }
12888 printf ("\"\n");
12889 }
12890 else
12891 {
12892 unsigned int len;
12893
12894 val = read_uleb128 (p, &len, end);
12895 p += len;
12896 printf ("%ld (0x%lx)\n", val, val);
12897 }
12898
12899 assert (p <= end);
12900 return p;
12901}
12902
12903/* ARM EABI attributes section. */
12904typedef struct
12905{
12906 unsigned int tag;
12907 const char * name;
12908 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12909 unsigned int type;
12910 const char ** table;
12911} arm_attr_public_tag;
12912
12913static const char * arm_attr_tag_CPU_arch[] =
12914 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12915 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12916 "v8-M.mainline"};
12917static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12918static const char * arm_attr_tag_THUMB_ISA_use[] =
12919 {"No", "Thumb-1", "Thumb-2", "Yes"};
12920static const char * arm_attr_tag_FP_arch[] =
12921 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12922 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12923static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12924static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12925 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12926 "NEON for ARMv8.1"};
12927static const char * arm_attr_tag_PCS_config[] =
12928 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12929 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12930static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12931 {"V6", "SB", "TLS", "Unused"};
12932static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12933 {"Absolute", "PC-relative", "SB-relative", "None"};
12934static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12935 {"Absolute", "PC-relative", "None"};
12936static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12937 {"None", "direct", "GOT-indirect"};
12938static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12939 {"None", "??? 1", "2", "??? 3", "4"};
12940static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12941static const char * arm_attr_tag_ABI_FP_denormal[] =
12942 {"Unused", "Needed", "Sign only"};
12943static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12944static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12945static const char * arm_attr_tag_ABI_FP_number_model[] =
12946 {"Unused", "Finite", "RTABI", "IEEE 754"};
12947static const char * arm_attr_tag_ABI_enum_size[] =
12948 {"Unused", "small", "int", "forced to int"};
12949static const char * arm_attr_tag_ABI_HardFP_use[] =
12950 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12951static const char * arm_attr_tag_ABI_VFP_args[] =
12952 {"AAPCS", "VFP registers", "custom", "compatible"};
12953static const char * arm_attr_tag_ABI_WMMX_args[] =
12954 {"AAPCS", "WMMX registers", "custom"};
12955static const char * arm_attr_tag_ABI_optimization_goals[] =
12956 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12957 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12958static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12959 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12960 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12961static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12962static const char * arm_attr_tag_FP_HP_extension[] =
12963 {"Not Allowed", "Allowed"};
12964static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12965 {"None", "IEEE 754", "Alternative Format"};
12966static const char * arm_attr_tag_DSP_extension[] =
12967 {"Follow architecture", "Allowed"};
12968static const char * arm_attr_tag_MPextension_use[] =
12969 {"Not Allowed", "Allowed"};
12970static const char * arm_attr_tag_DIV_use[] =
12971 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12972 "Allowed in v7-A with integer division extension"};
12973static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12974static const char * arm_attr_tag_Virtualization_use[] =
12975 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12976 "TrustZone and Virtualization Extensions"};
12977static const char * arm_attr_tag_MPextension_use_legacy[] =
12978 {"Not Allowed", "Allowed"};
12979
12980#define LOOKUP(id, name) \
12981 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12982static arm_attr_public_tag arm_attr_public_tags[] =
12983{
12984 {4, "CPU_raw_name", 1, NULL},
12985 {5, "CPU_name", 1, NULL},
12986 LOOKUP(6, CPU_arch),
12987 {7, "CPU_arch_profile", 0, NULL},
12988 LOOKUP(8, ARM_ISA_use),
12989 LOOKUP(9, THUMB_ISA_use),
12990 LOOKUP(10, FP_arch),
12991 LOOKUP(11, WMMX_arch),
12992 LOOKUP(12, Advanced_SIMD_arch),
12993 LOOKUP(13, PCS_config),
12994 LOOKUP(14, ABI_PCS_R9_use),
12995 LOOKUP(15, ABI_PCS_RW_data),
12996 LOOKUP(16, ABI_PCS_RO_data),
12997 LOOKUP(17, ABI_PCS_GOT_use),
12998 LOOKUP(18, ABI_PCS_wchar_t),
12999 LOOKUP(19, ABI_FP_rounding),
13000 LOOKUP(20, ABI_FP_denormal),
13001 LOOKUP(21, ABI_FP_exceptions),
13002 LOOKUP(22, ABI_FP_user_exceptions),
13003 LOOKUP(23, ABI_FP_number_model),
13004 {24, "ABI_align_needed", 0, NULL},
13005 {25, "ABI_align_preserved", 0, NULL},
13006 LOOKUP(26, ABI_enum_size),
13007 LOOKUP(27, ABI_HardFP_use),
13008 LOOKUP(28, ABI_VFP_args),
13009 LOOKUP(29, ABI_WMMX_args),
13010 LOOKUP(30, ABI_optimization_goals),
13011 LOOKUP(31, ABI_FP_optimization_goals),
13012 {32, "compatibility", 0, NULL},
13013 LOOKUP(34, CPU_unaligned_access),
13014 LOOKUP(36, FP_HP_extension),
13015 LOOKUP(38, ABI_FP_16bit_format),
13016 LOOKUP(42, MPextension_use),
13017 LOOKUP(44, DIV_use),
13018 LOOKUP(46, DSP_extension),
13019 {64, "nodefaults", 0, NULL},
13020 {65, "also_compatible_with", 0, NULL},
13021 LOOKUP(66, T2EE_use),
13022 {67, "conformance", 1, NULL},
13023 LOOKUP(68, Virtualization_use),
13024 LOOKUP(70, MPextension_use_legacy)
13025};
13026#undef LOOKUP
13027
13028static unsigned char *
13029display_arm_attribute (unsigned char * p,
13030 const unsigned char * const end)
13031{
13032 unsigned int tag;
13033 unsigned int len;
13034 unsigned int val;
13035 arm_attr_public_tag * attr;
13036 unsigned i;
13037 unsigned int type;
13038
13039 tag = read_uleb128 (p, &len, end);
13040 p += len;
13041 attr = NULL;
13042 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13043 {
13044 if (arm_attr_public_tags[i].tag == tag)
13045 {
13046 attr = &arm_attr_public_tags[i];
13047 break;
13048 }
13049 }
13050
13051 if (attr)
13052 {
13053 printf (" Tag_%s: ", attr->name);
13054 switch (attr->type)
13055 {
13056 case 0:
13057 switch (tag)
13058 {
13059 case 7: /* Tag_CPU_arch_profile. */
13060 val = read_uleb128 (p, &len, end);
13061 p += len;
13062 switch (val)
13063 {
13064 case 0: printf (_("None\n")); break;
13065 case 'A': printf (_("Application\n")); break;
13066 case 'R': printf (_("Realtime\n")); break;
13067 case 'M': printf (_("Microcontroller\n")); break;
13068 case 'S': printf (_("Application or Realtime\n")); break;
13069 default: printf ("??? (%d)\n", val); break;
13070 }
13071 break;
13072
13073 case 24: /* Tag_align_needed. */
13074 val = read_uleb128 (p, &len, end);
13075 p += len;
13076 switch (val)
13077 {
13078 case 0: printf (_("None\n")); break;
13079 case 1: printf (_("8-byte\n")); break;
13080 case 2: printf (_("4-byte\n")); break;
13081 case 3: printf ("??? 3\n"); break;
13082 default:
13083 if (val <= 12)
13084 printf (_("8-byte and up to %d-byte extended\n"),
13085 1 << val);
13086 else
13087 printf ("??? (%d)\n", val);
13088 break;
13089 }
13090 break;
13091
13092 case 25: /* Tag_align_preserved. */
13093 val = read_uleb128 (p, &len, end);
13094 p += len;
13095 switch (val)
13096 {
13097 case 0: printf (_("None\n")); break;
13098 case 1: printf (_("8-byte, except leaf SP\n")); break;
13099 case 2: printf (_("8-byte\n")); break;
13100 case 3: printf ("??? 3\n"); break;
13101 default:
13102 if (val <= 12)
13103 printf (_("8-byte and up to %d-byte extended\n"),
13104 1 << val);
13105 else
13106 printf ("??? (%d)\n", val);
13107 break;
13108 }
13109 break;
13110
13111 case 32: /* Tag_compatibility. */
13112 {
13113 val = read_uleb128 (p, &len, end);
13114 p += len;
13115 printf (_("flag = %d, vendor = "), val);
13116 if (p < end - 1)
13117 {
13118 size_t maxlen = (end - p) - 1;
13119
13120 print_symbol ((int) maxlen, (const char *) p);
13121 p += strnlen ((char *) p, maxlen) + 1;
13122 }
13123 else
13124 {
13125 printf (_("<corrupt>"));
13126 p = (unsigned char *) end;
13127 }
13128 putchar ('\n');
13129 }
13130 break;
13131
13132 case 64: /* Tag_nodefaults. */
13133 /* PR 17531: file: 001-505008-0.01. */
13134 if (p < end)
13135 p++;
13136 printf (_("True\n"));
13137 break;
13138
13139 case 65: /* Tag_also_compatible_with. */
13140 val = read_uleb128 (p, &len, end);
13141 p += len;
13142 if (val == 6 /* Tag_CPU_arch. */)
13143 {
13144 val = read_uleb128 (p, &len, end);
13145 p += len;
13146 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13147 printf ("??? (%d)\n", val);
13148 else
13149 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13150 }
13151 else
13152 printf ("???\n");
13153 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13154 ;
13155 break;
13156
13157 default:
13158 printf (_("<unknown: %d>\n"), tag);
13159 break;
13160 }
13161 return p;
13162
13163 case 1:
13164 return display_tag_value (-1, p, end);
13165 case 2:
13166 return display_tag_value (0, p, end);
13167
13168 default:
13169 assert (attr->type & 0x80);
13170 val = read_uleb128 (p, &len, end);
13171 p += len;
13172 type = attr->type & 0x7f;
13173 if (val >= type)
13174 printf ("??? (%d)\n", val);
13175 else
13176 printf ("%s\n", attr->table[val]);
13177 return p;
13178 }
13179 }
13180
13181 return display_tag_value (tag, p, end);
13182}
13183
13184static unsigned char *
13185display_gnu_attribute (unsigned char * p,
13186 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13187 const unsigned char * const end)
13188{
13189 int tag;
13190 unsigned int len;
13191 int val;
13192
13193 tag = read_uleb128 (p, &len, end);
13194 p += len;
13195
13196 /* Tag_compatibility is the only generic GNU attribute defined at
13197 present. */
13198 if (tag == 32)
13199 {
13200 val = read_uleb128 (p, &len, end);
13201 p += len;
13202
13203 printf (_("flag = %d, vendor = "), val);
13204 if (p == end)
13205 {
13206 printf (_("<corrupt>\n"));
13207 warn (_("corrupt vendor attribute\n"));
13208 }
13209 else
13210 {
13211 if (p < end - 1)
13212 {
13213 size_t maxlen = (end - p) - 1;
13214
13215 print_symbol ((int) maxlen, (const char *) p);
13216 p += strnlen ((char *) p, maxlen) + 1;
13217 }
13218 else
13219 {
13220 printf (_("<corrupt>"));
13221 p = (unsigned char *) end;
13222 }
13223 putchar ('\n');
13224 }
13225 return p;
13226 }
13227
13228 if ((tag & 2) == 0 && display_proc_gnu_attribute)
13229 return display_proc_gnu_attribute (p, tag, end);
13230
13231 return display_tag_value (tag, p, end);
13232}
13233
13234static unsigned char *
13235display_power_gnu_attribute (unsigned char * p,
13236 int tag,
13237 const unsigned char * const end)
13238{
13239 unsigned int len;
13240 int val;
13241
13242 if (tag == Tag_GNU_Power_ABI_FP)
13243 {
13244 val = read_uleb128 (p, &len, end);
13245 p += len;
13246 printf (" Tag_GNU_Power_ABI_FP: ");
13247
13248 switch (val)
13249 {
13250 case 0:
13251 printf (_("Hard or soft float\n"));
13252 break;
13253 case 1:
13254 printf (_("Hard float\n"));
13255 break;
13256 case 2:
13257 printf (_("Soft float\n"));
13258 break;
13259 case 3:
13260 printf (_("Single-precision hard float\n"));
13261 break;
13262 default:
13263 printf ("??? (%d)\n", val);
13264 break;
13265 }
13266 return p;
13267 }
13268
13269 if (tag == Tag_GNU_Power_ABI_Vector)
13270 {
13271 val = read_uleb128 (p, &len, end);
13272 p += len;
13273 printf (" Tag_GNU_Power_ABI_Vector: ");
13274 switch (val)
13275 {
13276 case 0:
13277 printf (_("Any\n"));
13278 break;
13279 case 1:
13280 printf (_("Generic\n"));
13281 break;
13282 case 2:
13283 printf ("AltiVec\n");
13284 break;
13285 case 3:
13286 printf ("SPE\n");
13287 break;
13288 default:
13289 printf ("??? (%d)\n", val);
13290 break;
13291 }
13292 return p;
13293 }
13294
13295 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13296 {
13297 if (p == end)
13298 {
13299 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13300 return p;
13301 }
13302
13303 val = read_uleb128 (p, &len, end);
13304 p += len;
13305 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13306 switch (val)
13307 {
13308 case 0:
13309 printf (_("Any\n"));
13310 break;
13311 case 1:
13312 printf ("r3/r4\n");
13313 break;
13314 case 2:
13315 printf (_("Memory\n"));
13316 break;
13317 default:
13318 printf ("??? (%d)\n", val);
13319 break;
13320 }
13321 return p;
13322 }
13323
13324 return display_tag_value (tag & 1, p, end);
13325}
13326
13327static unsigned char *
13328display_s390_gnu_attribute (unsigned char * p,
13329 int tag,
13330 const unsigned char * const end)
13331{
13332 unsigned int len;
13333 int val;
13334
13335 if (tag == Tag_GNU_S390_ABI_Vector)
13336 {
13337 val = read_uleb128 (p, &len, end);
13338 p += len;
13339 printf (" Tag_GNU_S390_ABI_Vector: ");
13340
13341 switch (val)
13342 {
13343 case 0:
13344 printf (_("any\n"));
13345 break;
13346 case 1:
13347 printf (_("software\n"));
13348 break;
13349 case 2:
13350 printf (_("hardware\n"));
13351 break;
13352 default:
13353 printf ("??? (%d)\n", val);
13354 break;
13355 }
13356 return p;
13357 }
13358
13359 return display_tag_value (tag & 1, p, end);
13360}
13361
13362static void
13363display_sparc_hwcaps (int mask)
13364{
13365 if (mask)
13366 {
13367 int first = 1;
13368
13369 if (mask & ELF_SPARC_HWCAP_MUL32)
13370 fputs ("mul32", stdout), first = 0;
13371 if (mask & ELF_SPARC_HWCAP_DIV32)
13372 printf ("%sdiv32", first ? "" : "|"), first = 0;
13373 if (mask & ELF_SPARC_HWCAP_FSMULD)
13374 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13375 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13376 printf ("%sv8plus", first ? "" : "|"), first = 0;
13377 if (mask & ELF_SPARC_HWCAP_POPC)
13378 printf ("%spopc", first ? "" : "|"), first = 0;
13379 if (mask & ELF_SPARC_HWCAP_VIS)
13380 printf ("%svis", first ? "" : "|"), first = 0;
13381 if (mask & ELF_SPARC_HWCAP_VIS2)
13382 printf ("%svis2", first ? "" : "|"), first = 0;
13383 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13384 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13385 if (mask & ELF_SPARC_HWCAP_FMAF)
13386 printf ("%sfmaf", first ? "" : "|"), first = 0;
13387 if (mask & ELF_SPARC_HWCAP_VIS3)
13388 printf ("%svis3", first ? "" : "|"), first = 0;
13389 if (mask & ELF_SPARC_HWCAP_HPC)
13390 printf ("%shpc", first ? "" : "|"), first = 0;
13391 if (mask & ELF_SPARC_HWCAP_RANDOM)
13392 printf ("%srandom", first ? "" : "|"), first = 0;
13393 if (mask & ELF_SPARC_HWCAP_TRANS)
13394 printf ("%strans", first ? "" : "|"), first = 0;
13395 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13396 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13397 if (mask & ELF_SPARC_HWCAP_IMA)
13398 printf ("%sima", first ? "" : "|"), first = 0;
13399 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13400 printf ("%scspare", first ? "" : "|"), first = 0;
13401 }
13402 else
13403 fputc ('0', stdout);
13404 fputc ('\n', stdout);
13405}
13406
13407static void
13408display_sparc_hwcaps2 (int mask)
13409{
13410 if (mask)
13411 {
13412 int first = 1;
13413
13414 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13415 fputs ("fjathplus", stdout), first = 0;
13416 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13417 printf ("%svis3b", first ? "" : "|"), first = 0;
13418 if (mask & ELF_SPARC_HWCAP2_ADP)
13419 printf ("%sadp", first ? "" : "|"), first = 0;
13420 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13421 printf ("%ssparc5", first ? "" : "|"), first = 0;
13422 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13423 printf ("%smwait", first ? "" : "|"), first = 0;
13424 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13425 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13426 if (mask & ELF_SPARC_HWCAP2_XMONT)
13427 printf ("%sxmont2", first ? "" : "|"), first = 0;
13428 if (mask & ELF_SPARC_HWCAP2_NSEC)
13429 printf ("%snsec", first ? "" : "|"), first = 0;
13430 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13431 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13432 if (mask & ELF_SPARC_HWCAP2_FJDES)
13433 printf ("%sfjdes", first ? "" : "|"), first = 0;
13434 if (mask & ELF_SPARC_HWCAP2_FJAES)
13435 printf ("%sfjaes", first ? "" : "|"), first = 0;
13436 }
13437 else
13438 fputc ('0', stdout);
13439 fputc ('\n', stdout);
13440}
13441
13442static unsigned char *
13443display_sparc_gnu_attribute (unsigned char * p,
13444 int tag,
13445 const unsigned char * const end)
13446{
13447 unsigned int len;
13448 int val;
13449
13450 if (tag == Tag_GNU_Sparc_HWCAPS)
13451 {
13452 val = read_uleb128 (p, &len, end);
13453 p += len;
13454 printf (" Tag_GNU_Sparc_HWCAPS: ");
13455 display_sparc_hwcaps (val);
13456 return p;
13457 }
13458 if (tag == Tag_GNU_Sparc_HWCAPS2)
13459 {
13460 val = read_uleb128 (p, &len, end);
13461 p += len;
13462 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13463 display_sparc_hwcaps2 (val);
13464 return p;
13465 }
13466
13467 return display_tag_value (tag, p, end);
13468}
13469
13470static void
13471print_mips_fp_abi_value (int val)
13472{
13473 switch (val)
13474 {
13475 case Val_GNU_MIPS_ABI_FP_ANY:
13476 printf (_("Hard or soft float\n"));
13477 break;
13478 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13479 printf (_("Hard float (double precision)\n"));
13480 break;
13481 case Val_GNU_MIPS_ABI_FP_SINGLE:
13482 printf (_("Hard float (single precision)\n"));
13483 break;
13484 case Val_GNU_MIPS_ABI_FP_SOFT:
13485 printf (_("Soft float\n"));
13486 break;
13487 case Val_GNU_MIPS_ABI_FP_OLD_64:
13488 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13489 break;
13490 case Val_GNU_MIPS_ABI_FP_XX:
13491 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13492 break;
13493 case Val_GNU_MIPS_ABI_FP_64:
13494 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13495 break;
13496 case Val_GNU_MIPS_ABI_FP_64A:
13497 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13498 break;
13499 case Val_GNU_MIPS_ABI_FP_NAN2008:
13500 printf (_("NaN 2008 compatibility\n"));
13501 break;
13502 default:
13503 printf ("??? (%d)\n", val);
13504 break;
13505 }
13506}
13507
13508static unsigned char *
13509display_mips_gnu_attribute (unsigned char * p,
13510 int tag,
13511 const unsigned char * const end)
13512{
13513 if (tag == Tag_GNU_MIPS_ABI_FP)
13514 {
13515 unsigned int len;
13516 int val;
13517
13518 val = read_uleb128 (p, &len, end);
13519 p += len;
13520 printf (" Tag_GNU_MIPS_ABI_FP: ");
13521
13522 print_mips_fp_abi_value (val);
13523
13524 return p;
13525 }
13526
13527 if (tag == Tag_GNU_MIPS_ABI_MSA)
13528 {
13529 unsigned int len;
13530 int val;
13531
13532 val = read_uleb128 (p, &len, end);
13533 p += len;
13534 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13535
13536 switch (val)
13537 {
13538 case Val_GNU_MIPS_ABI_MSA_ANY:
13539 printf (_("Any MSA or not\n"));
13540 break;
13541 case Val_GNU_MIPS_ABI_MSA_128:
13542 printf (_("128-bit MSA\n"));
13543 break;
13544 default:
13545 printf ("??? (%d)\n", val);
13546 break;
13547 }
13548 return p;
13549 }
13550
13551 return display_tag_value (tag & 1, p, end);
13552}
13553
13554static unsigned char *
13555display_tic6x_attribute (unsigned char * p,
13556 const unsigned char * const end)
13557{
13558 int tag;
13559 unsigned int len;
13560 int val;
13561
13562 tag = read_uleb128 (p, &len, end);
13563 p += len;
13564
13565 switch (tag)
13566 {
13567 case Tag_ISA:
13568 val = read_uleb128 (p, &len, end);
13569 p += len;
13570 printf (" Tag_ISA: ");
13571
13572 switch (val)
13573 {
13574 case C6XABI_Tag_ISA_none:
13575 printf (_("None\n"));
13576 break;
13577 case C6XABI_Tag_ISA_C62X:
13578 printf ("C62x\n");
13579 break;
13580 case C6XABI_Tag_ISA_C67X:
13581 printf ("C67x\n");
13582 break;
13583 case C6XABI_Tag_ISA_C67XP:
13584 printf ("C67x+\n");
13585 break;
13586 case C6XABI_Tag_ISA_C64X:
13587 printf ("C64x\n");
13588 break;
13589 case C6XABI_Tag_ISA_C64XP:
13590 printf ("C64x+\n");
13591 break;
13592 case C6XABI_Tag_ISA_C674X:
13593 printf ("C674x\n");
13594 break;
13595 default:
13596 printf ("??? (%d)\n", val);
13597 break;
13598 }
13599 return p;
13600
13601 case Tag_ABI_wchar_t:
13602 val = read_uleb128 (p, &len, end);
13603 p += len;
13604 printf (" Tag_ABI_wchar_t: ");
13605 switch (val)
13606 {
13607 case 0:
13608 printf (_("Not used\n"));
13609 break;
13610 case 1:
13611 printf (_("2 bytes\n"));
13612 break;
13613 case 2:
13614 printf (_("4 bytes\n"));
13615 break;
13616 default:
13617 printf ("??? (%d)\n", val);
13618 break;
13619 }
13620 return p;
13621
13622 case Tag_ABI_stack_align_needed:
13623 val = read_uleb128 (p, &len, end);
13624 p += len;
13625 printf (" Tag_ABI_stack_align_needed: ");
13626 switch (val)
13627 {
13628 case 0:
13629 printf (_("8-byte\n"));
13630 break;
13631 case 1:
13632 printf (_("16-byte\n"));
13633 break;
13634 default:
13635 printf ("??? (%d)\n", val);
13636 break;
13637 }
13638 return p;
13639
13640 case Tag_ABI_stack_align_preserved:
13641 val = read_uleb128 (p, &len, end);
13642 p += len;
13643 printf (" Tag_ABI_stack_align_preserved: ");
13644 switch (val)
13645 {
13646 case 0:
13647 printf (_("8-byte\n"));
13648 break;
13649 case 1:
13650 printf (_("16-byte\n"));
13651 break;
13652 default:
13653 printf ("??? (%d)\n", val);
13654 break;
13655 }
13656 return p;
13657
13658 case Tag_ABI_DSBT:
13659 val = read_uleb128 (p, &len, end);
13660 p += len;
13661 printf (" Tag_ABI_DSBT: ");
13662 switch (val)
13663 {
13664 case 0:
13665 printf (_("DSBT addressing not used\n"));
13666 break;
13667 case 1:
13668 printf (_("DSBT addressing used\n"));
13669 break;
13670 default:
13671 printf ("??? (%d)\n", val);
13672 break;
13673 }
13674 return p;
13675
13676 case Tag_ABI_PID:
13677 val = read_uleb128 (p, &len, end);
13678 p += len;
13679 printf (" Tag_ABI_PID: ");
13680 switch (val)
13681 {
13682 case 0:
13683 printf (_("Data addressing position-dependent\n"));
13684 break;
13685 case 1:
13686 printf (_("Data addressing position-independent, GOT near DP\n"));
13687 break;
13688 case 2:
13689 printf (_("Data addressing position-independent, GOT far from DP\n"));
13690 break;
13691 default:
13692 printf ("??? (%d)\n", val);
13693 break;
13694 }
13695 return p;
13696
13697 case Tag_ABI_PIC:
13698 val = read_uleb128 (p, &len, end);
13699 p += len;
13700 printf (" Tag_ABI_PIC: ");
13701 switch (val)
13702 {
13703 case 0:
13704 printf (_("Code addressing position-dependent\n"));
13705 break;
13706 case 1:
13707 printf (_("Code addressing position-independent\n"));
13708 break;
13709 default:
13710 printf ("??? (%d)\n", val);
13711 break;
13712 }
13713 return p;
13714
13715 case Tag_ABI_array_object_alignment:
13716 val = read_uleb128 (p, &len, end);
13717 p += len;
13718 printf (" Tag_ABI_array_object_alignment: ");
13719 switch (val)
13720 {
13721 case 0:
13722 printf (_("8-byte\n"));
13723 break;
13724 case 1:
13725 printf (_("4-byte\n"));
13726 break;
13727 case 2:
13728 printf (_("16-byte\n"));
13729 break;
13730 default:
13731 printf ("??? (%d)\n", val);
13732 break;
13733 }
13734 return p;
13735
13736 case Tag_ABI_array_object_align_expected:
13737 val = read_uleb128 (p, &len, end);
13738 p += len;
13739 printf (" Tag_ABI_array_object_align_expected: ");
13740 switch (val)
13741 {
13742 case 0:
13743 printf (_("8-byte\n"));
13744 break;
13745 case 1:
13746 printf (_("4-byte\n"));
13747 break;
13748 case 2:
13749 printf (_("16-byte\n"));
13750 break;
13751 default:
13752 printf ("??? (%d)\n", val);
13753 break;
13754 }
13755 return p;
13756
13757 case Tag_ABI_compatibility:
13758 {
13759 val = read_uleb128 (p, &len, end);
13760 p += len;
13761 printf (" Tag_ABI_compatibility: ");
13762 printf (_("flag = %d, vendor = "), val);
13763 if (p < end - 1)
13764 {
13765 size_t maxlen = (end - p) - 1;
13766
13767 print_symbol ((int) maxlen, (const char *) p);
13768 p += strnlen ((char *) p, maxlen) + 1;
13769 }
13770 else
13771 {
13772 printf (_("<corrupt>"));
13773 p = (unsigned char *) end;
13774 }
13775 putchar ('\n');
13776 return p;
13777 }
13778
13779 case Tag_ABI_conformance:
13780 {
13781 printf (" Tag_ABI_conformance: \"");
13782 if (p < end - 1)
13783 {
13784 size_t maxlen = (end - p) - 1;
13785
13786 print_symbol ((int) maxlen, (const char *) p);
13787 p += strnlen ((char *) p, maxlen) + 1;
13788 }
13789 else
13790 {
13791 printf (_("<corrupt>"));
13792 p = (unsigned char *) end;
13793 }
13794 printf ("\"\n");
13795 return p;
13796 }
13797 }
13798
13799 return display_tag_value (tag, p, end);
13800}
13801
13802static void
13803display_raw_attribute (unsigned char * p, unsigned char * end)
13804{
13805 unsigned long addr = 0;
13806 size_t bytes = end - p;
13807
13808 assert (end > p);
13809 while (bytes)
13810 {
13811 int j;
13812 int k;
13813 int lbytes = (bytes > 16 ? 16 : bytes);
13814
13815 printf (" 0x%8.8lx ", addr);
13816
13817 for (j = 0; j < 16; j++)
13818 {
13819 if (j < lbytes)
13820 printf ("%2.2x", p[j]);
13821 else
13822 printf (" ");
13823
13824 if ((j & 3) == 3)
13825 printf (" ");
13826 }
13827
13828 for (j = 0; j < lbytes; j++)
13829 {
13830 k = p[j];
13831 if (k >= ' ' && k < 0x7f)
13832 printf ("%c", k);
13833 else
13834 printf (".");
13835 }
13836
13837 putchar ('\n');
13838
13839 p += lbytes;
13840 bytes -= lbytes;
13841 addr += lbytes;
13842 }
13843
13844 putchar ('\n');
13845}
13846
13847static unsigned char *
13848display_msp430x_attribute (unsigned char * p,
13849 const unsigned char * const end)
13850{
13851 unsigned int len;
13852 int val;
13853 int tag;
13854
13855 tag = read_uleb128 (p, & len, end);
13856 p += len;
13857
13858 switch (tag)
13859 {
13860 case OFBA_MSPABI_Tag_ISA:
13861 val = read_uleb128 (p, &len, end);
13862 p += len;
13863 printf (" Tag_ISA: ");
13864 switch (val)
13865 {
13866 case 0: printf (_("None\n")); break;
13867 case 1: printf (_("MSP430\n")); break;
13868 case 2: printf (_("MSP430X\n")); break;
13869 default: printf ("??? (%d)\n", val); break;
13870 }
13871 break;
13872
13873 case OFBA_MSPABI_Tag_Code_Model:
13874 val = read_uleb128 (p, &len, end);
13875 p += len;
13876 printf (" Tag_Code_Model: ");
13877 switch (val)
13878 {
13879 case 0: printf (_("None\n")); break;
13880 case 1: printf (_("Small\n")); break;
13881 case 2: printf (_("Large\n")); break;
13882 default: printf ("??? (%d)\n", val); break;
13883 }
13884 break;
13885
13886 case OFBA_MSPABI_Tag_Data_Model:
13887 val = read_uleb128 (p, &len, end);
13888 p += len;
13889 printf (" Tag_Data_Model: ");
13890 switch (val)
13891 {
13892 case 0: printf (_("None\n")); break;
13893 case 1: printf (_("Small\n")); break;
13894 case 2: printf (_("Large\n")); break;
13895 case 3: printf (_("Restricted Large\n")); break;
13896 default: printf ("??? (%d)\n", val); break;
13897 }
13898 break;
13899
13900 default:
13901 printf (_(" <unknown tag %d>: "), tag);
13902
13903 if (tag & 1)
13904 {
13905 putchar ('"');
13906 if (p < end - 1)
13907 {
13908 size_t maxlen = (end - p) - 1;
13909
13910 print_symbol ((int) maxlen, (const char *) p);
13911 p += strnlen ((char *) p, maxlen) + 1;
13912 }
13913 else
13914 {
13915 printf (_("<corrupt>"));
13916 p = (unsigned char *) end;
13917 }
13918 printf ("\"\n");
13919 }
13920 else
13921 {
13922 val = read_uleb128 (p, &len, end);
13923 p += len;
13924 printf ("%d (0x%x)\n", val, val);
13925 }
13926 break;
13927 }
13928
13929 assert (p <= end);
13930 return p;
13931}
13932
13933static int
13934process_attributes (FILE * file,
13935 const char * public_name,
13936 unsigned int proc_type,
13937 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13938 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13939{
13940 Elf_Internal_Shdr * sect;
13941 unsigned i;
13942
13943 /* Find the section header so that we get the size. */
13944 for (i = 0, sect = section_headers;
13945 i < elf_header.e_shnum;
13946 i++, sect++)
13947 {
13948 unsigned char * contents;
13949 unsigned char * p;
13950
13951 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13952 continue;
13953
13954 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13955 sect->sh_size, _("attributes"));
13956 if (contents == NULL)
13957 continue;
13958
13959 p = contents;
13960 if (*p == 'A')
13961 {
13962 bfd_vma section_len;
13963
13964 section_len = sect->sh_size - 1;
13965 p++;
13966
13967 while (section_len > 0)
13968 {
13969 bfd_vma attr_len;
13970 unsigned int namelen;
13971 bfd_boolean public_section;
13972 bfd_boolean gnu_section;
13973
13974 if (section_len <= 4)
13975 {
13976 error (_("Tag section ends prematurely\n"));
13977 break;
13978 }
13979 attr_len = byte_get (p, 4);
13980 p += 4;
13981
13982 if (attr_len > section_len)
13983 {
13984 error (_("Bad attribute length (%u > %u)\n"),
13985 (unsigned) attr_len, (unsigned) section_len);
13986 attr_len = section_len;
13987 }
13988 /* PR 17531: file: 001-101425-0.004 */
13989 else if (attr_len < 5)
13990 {
13991 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13992 break;
13993 }
13994
13995 section_len -= attr_len;
13996 attr_len -= 4;
13997
13998 namelen = strnlen ((char *) p, attr_len) + 1;
13999 if (namelen == 0 || namelen >= attr_len)
14000 {
14001 error (_("Corrupt attribute section name\n"));
14002 break;
14003 }
14004
14005 printf (_("Attribute Section: "));
14006 print_symbol (INT_MAX, (const char *) p);
14007 putchar ('\n');
14008
14009 if (public_name && streq ((char *) p, public_name))
14010 public_section = TRUE;
14011 else
14012 public_section = FALSE;
14013
14014 if (streq ((char *) p, "gnu"))
14015 gnu_section = TRUE;
14016 else
14017 gnu_section = FALSE;
14018
14019 p += namelen;
14020 attr_len -= namelen;
14021
14022 while (attr_len > 0 && p < contents + sect->sh_size)
14023 {
14024 int tag;
14025 int val;
14026 bfd_vma size;
14027 unsigned char * end;
14028
14029 /* PR binutils/17531: Safe handling of corrupt files. */
14030 if (attr_len < 6)
14031 {
14032 error (_("Unused bytes at end of section\n"));
14033 section_len = 0;
14034 break;
14035 }
14036
14037 tag = *(p++);
14038 size = byte_get (p, 4);
14039 if (size > attr_len)
14040 {
14041 error (_("Bad subsection length (%u > %u)\n"),
14042 (unsigned) size, (unsigned) attr_len);
14043 size = attr_len;
14044 }
14045 /* PR binutils/17531: Safe handling of corrupt files. */
14046 if (size < 6)
14047 {
14048 error (_("Bad subsection length (%u < 6)\n"),
14049 (unsigned) size);
14050 section_len = 0;
14051 break;
14052 }
14053
14054 attr_len -= size;
14055 end = p + size - 1;
14056 assert (end <= contents + sect->sh_size);
14057 p += 4;
14058
14059 switch (tag)
14060 {
14061 case 1:
14062 printf (_("File Attributes\n"));
14063 break;
14064 case 2:
14065 printf (_("Section Attributes:"));
14066 goto do_numlist;
14067 case 3:
14068 printf (_("Symbol Attributes:"));
14069 do_numlist:
14070 for (;;)
14071 {
14072 unsigned int j;
14073
14074 val = read_uleb128 (p, &j, end);
14075 p += j;
14076 if (val == 0)
14077 break;
14078 printf (" %d", val);
14079 }
14080 printf ("\n");
14081 break;
14082 default:
14083 printf (_("Unknown tag: %d\n"), tag);
14084 public_section = FALSE;
14085 break;
14086 }
14087
14088 if (public_section && display_pub_attribute != NULL)
14089 {
14090 while (p < end)
14091 p = display_pub_attribute (p, end);
14092 assert (p <= end);
14093 }
14094 else if (gnu_section && display_proc_gnu_attribute != NULL)
14095 {
14096 while (p < end)
14097 p = display_gnu_attribute (p,
14098 display_proc_gnu_attribute,
14099 end);
14100 assert (p <= end);
14101 }
14102 else if (p < end)
14103 {
14104 printf (_(" Unknown attribute:\n"));
14105 display_raw_attribute (p, end);
14106 p = end;
14107 }
14108 else
14109 attr_len = 0;
14110 }
14111 }
14112 }
14113 else
14114 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
14115
14116 free (contents);
14117 }
14118 return 1;
14119}
14120
14121static int
14122process_arm_specific (FILE * file)
14123{
14124 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14125 display_arm_attribute, NULL);
14126}
14127
14128static int
14129process_power_specific (FILE * file)
14130{
14131 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14132 display_power_gnu_attribute);
14133}
14134
14135static int
14136process_s390_specific (FILE * file)
14137{
14138 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14139 display_s390_gnu_attribute);
14140}
14141
14142static int
14143process_sparc_specific (FILE * file)
14144{
14145 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14146 display_sparc_gnu_attribute);
14147}
14148
14149static int
14150process_tic6x_specific (FILE * file)
14151{
14152 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14153 display_tic6x_attribute, NULL);
14154}
14155
14156static int
14157process_msp430x_specific (FILE * file)
14158{
14159 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14160 display_msp430x_attribute, NULL);
14161}
14162
14163/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14164 Print the Address, Access and Initial fields of an entry at VMA ADDR
14165 and return the VMA of the next entry, or -1 if there was a problem.
14166 Does not read from DATA_END or beyond. */
14167
14168static bfd_vma
14169print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14170 unsigned char * data_end)
14171{
14172 printf (" ");
14173 print_vma (addr, LONG_HEX);
14174 printf (" ");
14175 if (addr < pltgot + 0xfff0)
14176 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14177 else
14178 printf ("%10s", "");
14179 printf (" ");
14180 if (data == NULL)
14181 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14182 else
14183 {
14184 bfd_vma entry;
14185 unsigned char * from = data + addr - pltgot;
14186
14187 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14188 {
14189 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14190 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14191 return (bfd_vma) -1;
14192 }
14193 else
14194 {
14195 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14196 print_vma (entry, LONG_HEX);
14197 }
14198 }
14199 return addr + (is_32bit_elf ? 4 : 8);
14200}
14201
14202/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14203 PLTGOT. Print the Address and Initial fields of an entry at VMA
14204 ADDR and return the VMA of the next entry. */
14205
14206static bfd_vma
14207print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14208{
14209 printf (" ");
14210 print_vma (addr, LONG_HEX);
14211 printf (" ");
14212 if (data == NULL)
14213 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14214 else
14215 {
14216 bfd_vma entry;
14217
14218 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14219 print_vma (entry, LONG_HEX);
14220 }
14221 return addr + (is_32bit_elf ? 4 : 8);
14222}
14223
14224static void
14225print_mips_ases (unsigned int mask)
14226{
14227 if (mask & AFL_ASE_DSP)
14228 fputs ("\n\tDSP ASE", stdout);
14229 if (mask & AFL_ASE_DSPR2)
14230 fputs ("\n\tDSP R2 ASE", stdout);
14231 if (mask & AFL_ASE_DSPR3)
14232 fputs ("\n\tDSP R3 ASE", stdout);
14233 if (mask & AFL_ASE_EVA)
14234 fputs ("\n\tEnhanced VA Scheme", stdout);
14235 if (mask & AFL_ASE_MCU)
14236 fputs ("\n\tMCU (MicroController) ASE", stdout);
14237 if (mask & AFL_ASE_MDMX)
14238 fputs ("\n\tMDMX ASE", stdout);
14239 if (mask & AFL_ASE_MIPS3D)
14240 fputs ("\n\tMIPS-3D ASE", stdout);
14241 if (mask & AFL_ASE_MT)
14242 fputs ("\n\tMT ASE", stdout);
14243 if (mask & AFL_ASE_SMARTMIPS)
14244 fputs ("\n\tSmartMIPS ASE", stdout);
14245 if (mask & AFL_ASE_VIRT)
14246 fputs ("\n\tVZ ASE", stdout);
14247 if (mask & AFL_ASE_MSA)
14248 fputs ("\n\tMSA ASE", stdout);
14249 if (mask & AFL_ASE_MIPS16)
14250 fputs ("\n\tMIPS16 ASE", stdout);
14251 if (mask & AFL_ASE_MICROMIPS)
14252 fputs ("\n\tMICROMIPS ASE", stdout);
14253 if (mask & AFL_ASE_XPA)
14254 fputs ("\n\tXPA ASE", stdout);
14255 if (mask == 0)
14256 fprintf (stdout, "\n\t%s", _("None"));
14257 else if ((mask & ~AFL_ASE_MASK) != 0)
14258 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14259}
14260
14261static void
14262print_mips_isa_ext (unsigned int isa_ext)
14263{
14264 switch (isa_ext)
14265 {
14266 case 0:
14267 fputs (_("None"), stdout);
14268 break;
14269 case AFL_EXT_XLR:
14270 fputs ("RMI XLR", stdout);
14271 break;
14272 case AFL_EXT_OCTEON3:
14273 fputs ("Cavium Networks Octeon3", stdout);
14274 break;
14275 case AFL_EXT_OCTEON2:
14276 fputs ("Cavium Networks Octeon2", stdout);
14277 break;
14278 case AFL_EXT_OCTEONP:
14279 fputs ("Cavium Networks OcteonP", stdout);
14280 break;
14281 case AFL_EXT_LOONGSON_3A:
14282 fputs ("Loongson 3A", stdout);
14283 break;
14284 case AFL_EXT_OCTEON:
14285 fputs ("Cavium Networks Octeon", stdout);
14286 break;
14287 case AFL_EXT_5900:
14288 fputs ("Toshiba R5900", stdout);
14289 break;
14290 case AFL_EXT_4650:
14291 fputs ("MIPS R4650", stdout);
14292 break;
14293 case AFL_EXT_4010:
14294 fputs ("LSI R4010", stdout);
14295 break;
14296 case AFL_EXT_4100:
14297 fputs ("NEC VR4100", stdout);
14298 break;
14299 case AFL_EXT_3900:
14300 fputs ("Toshiba R3900", stdout);
14301 break;
14302 case AFL_EXT_10000:
14303 fputs ("MIPS R10000", stdout);
14304 break;
14305 case AFL_EXT_SB1:
14306 fputs ("Broadcom SB-1", stdout);
14307 break;
14308 case AFL_EXT_4111:
14309 fputs ("NEC VR4111/VR4181", stdout);
14310 break;
14311 case AFL_EXT_4120:
14312 fputs ("NEC VR4120", stdout);
14313 break;
14314 case AFL_EXT_5400:
14315 fputs ("NEC VR5400", stdout);
14316 break;
14317 case AFL_EXT_5500:
14318 fputs ("NEC VR5500", stdout);
14319 break;
14320 case AFL_EXT_LOONGSON_2E:
14321 fputs ("ST Microelectronics Loongson 2E", stdout);
14322 break;
14323 case AFL_EXT_LOONGSON_2F:
14324 fputs ("ST Microelectronics Loongson 2F", stdout);
14325 break;
14326 default:
14327 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14328 }
14329}
14330
14331static int
14332get_mips_reg_size (int reg_size)
14333{
14334 return (reg_size == AFL_REG_NONE) ? 0
14335 : (reg_size == AFL_REG_32) ? 32
14336 : (reg_size == AFL_REG_64) ? 64
14337 : (reg_size == AFL_REG_128) ? 128
14338 : -1;
14339}
14340
14341static int
14342process_mips_specific (FILE * file)
14343{
14344 Elf_Internal_Dyn * entry;
14345 Elf_Internal_Shdr *sect = NULL;
14346 size_t liblist_offset = 0;
14347 size_t liblistno = 0;
14348 size_t conflictsno = 0;
14349 size_t options_offset = 0;
14350 size_t conflicts_offset = 0;
14351 size_t pltrelsz = 0;
14352 size_t pltrel = 0;
14353 bfd_vma pltgot = 0;
14354 bfd_vma mips_pltgot = 0;
14355 bfd_vma jmprel = 0;
14356 bfd_vma local_gotno = 0;
14357 bfd_vma gotsym = 0;
14358 bfd_vma symtabno = 0;
14359
14360 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14361 display_mips_gnu_attribute);
14362
14363 sect = find_section (".MIPS.abiflags");
14364
14365 if (sect != NULL)
14366 {
14367 Elf_External_ABIFlags_v0 *abiflags_ext;
14368 Elf_Internal_ABIFlags_v0 abiflags_in;
14369
14370 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14371 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14372 else
14373 {
14374 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14375 sect->sh_size, _("MIPS ABI Flags section"));
14376 if (abiflags_ext)
14377 {
14378 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14379 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14380 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14381 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14382 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14383 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14384 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14385 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14386 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14387 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14388 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14389
14390 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14391 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14392 if (abiflags_in.isa_rev > 1)
14393 printf ("r%d", abiflags_in.isa_rev);
14394 printf ("\nGPR size: %d",
14395 get_mips_reg_size (abiflags_in.gpr_size));
14396 printf ("\nCPR1 size: %d",
14397 get_mips_reg_size (abiflags_in.cpr1_size));
14398 printf ("\nCPR2 size: %d",
14399 get_mips_reg_size (abiflags_in.cpr2_size));
14400 fputs ("\nFP ABI: ", stdout);
14401 print_mips_fp_abi_value (abiflags_in.fp_abi);
14402 fputs ("ISA Extension: ", stdout);
14403 print_mips_isa_ext (abiflags_in.isa_ext);
14404 fputs ("\nASEs:", stdout);
14405 print_mips_ases (abiflags_in.ases);
14406 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14407 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14408 fputc ('\n', stdout);
14409 free (abiflags_ext);
14410 }
14411 }
14412 }
14413
14414 /* We have a lot of special sections. Thanks SGI! */
14415 if (dynamic_section == NULL)
14416 /* No information available. */
14417 return 0;
14418
14419 for (entry = dynamic_section;
14420 /* PR 17531 file: 012-50589-0.004. */
14421 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14422 ++entry)
14423 switch (entry->d_tag)
14424 {
14425 case DT_MIPS_LIBLIST:
14426 liblist_offset
14427 = offset_from_vma (file, entry->d_un.d_val,
14428 liblistno * sizeof (Elf32_External_Lib));
14429 break;
14430 case DT_MIPS_LIBLISTNO:
14431 liblistno = entry->d_un.d_val;
14432 break;
14433 case DT_MIPS_OPTIONS:
14434 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14435 break;
14436 case DT_MIPS_CONFLICT:
14437 conflicts_offset
14438 = offset_from_vma (file, entry->d_un.d_val,
14439 conflictsno * sizeof (Elf32_External_Conflict));
14440 break;
14441 case DT_MIPS_CONFLICTNO:
14442 conflictsno = entry->d_un.d_val;
14443 break;
14444 case DT_PLTGOT:
14445 pltgot = entry->d_un.d_ptr;
14446 break;
14447 case DT_MIPS_LOCAL_GOTNO:
14448 local_gotno = entry->d_un.d_val;
14449 break;
14450 case DT_MIPS_GOTSYM:
14451 gotsym = entry->d_un.d_val;
14452 break;
14453 case DT_MIPS_SYMTABNO:
14454 symtabno = entry->d_un.d_val;
14455 break;
14456 case DT_MIPS_PLTGOT:
14457 mips_pltgot = entry->d_un.d_ptr;
14458 break;
14459 case DT_PLTREL:
14460 pltrel = entry->d_un.d_val;
14461 break;
14462 case DT_PLTRELSZ:
14463 pltrelsz = entry->d_un.d_val;
14464 break;
14465 case DT_JMPREL:
14466 jmprel = entry->d_un.d_ptr;
14467 break;
14468 default:
14469 break;
14470 }
14471
14472 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14473 {
14474 Elf32_External_Lib * elib;
14475 size_t cnt;
14476
14477 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14478 liblistno,
14479 sizeof (Elf32_External_Lib),
14480 _("liblist section data"));
14481 if (elib)
14482 {
14483 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14484 (unsigned long) liblistno);
14485 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14486 stdout);
14487
14488 for (cnt = 0; cnt < liblistno; ++cnt)
14489 {
14490 Elf32_Lib liblist;
14491 time_t atime;
14492 char timebuf[128];
14493 struct tm * tmp;
14494
14495 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14496 atime = BYTE_GET (elib[cnt].l_time_stamp);
14497 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14498 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14499 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14500
14501 tmp = gmtime (&atime);
14502 snprintf (timebuf, sizeof (timebuf),
14503 "%04u-%02u-%02uT%02u:%02u:%02u",
14504 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14505 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14506
14507 printf ("%3lu: ", (unsigned long) cnt);
14508 if (VALID_DYNAMIC_NAME (liblist.l_name))
14509 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14510 else
14511 printf (_("<corrupt: %9ld>"), liblist.l_name);
14512 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14513 liblist.l_version);
14514
14515 if (liblist.l_flags == 0)
14516 puts (_(" NONE"));
14517 else
14518 {
14519 static const struct
14520 {
14521 const char * name;
14522 int bit;
14523 }
14524 l_flags_vals[] =
14525 {
14526 { " EXACT_MATCH", LL_EXACT_MATCH },
14527 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14528 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14529 { " EXPORTS", LL_EXPORTS },
14530 { " DELAY_LOAD", LL_DELAY_LOAD },
14531 { " DELTA", LL_DELTA }
14532 };
14533 int flags = liblist.l_flags;
14534 size_t fcnt;
14535
14536 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14537 if ((flags & l_flags_vals[fcnt].bit) != 0)
14538 {
14539 fputs (l_flags_vals[fcnt].name, stdout);
14540 flags ^= l_flags_vals[fcnt].bit;
14541 }
14542 if (flags != 0)
14543 printf (" %#x", (unsigned int) flags);
14544
14545 puts ("");
14546 }
14547 }
14548
14549 free (elib);
14550 }
14551 }
14552
14553 if (options_offset != 0)
14554 {
14555 Elf_External_Options * eopt;
14556 Elf_Internal_Options * iopt;
14557 Elf_Internal_Options * option;
14558 size_t offset;
14559 int cnt;
14560 sect = section_headers;
14561
14562 /* Find the section header so that we get the size. */
14563 sect = find_section_by_type (SHT_MIPS_OPTIONS);
14564 /* PR 17533 file: 012-277276-0.004. */
14565 if (sect == NULL)
14566 {
14567 error (_("No MIPS_OPTIONS header found\n"));
14568 return 0;
14569 }
14570
14571 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14572 sect->sh_size, _("options"));
14573 if (eopt)
14574 {
14575 iopt = (Elf_Internal_Options *)
14576 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14577 if (iopt == NULL)
14578 {
14579 error (_("Out of memory allocatinf space for MIPS options\n"));
14580 return 0;
14581 }
14582
14583 offset = cnt = 0;
14584 option = iopt;
14585
14586 while (offset <= sect->sh_size - sizeof (* eopt))
14587 {
14588 Elf_External_Options * eoption;
14589
14590 eoption = (Elf_External_Options *) ((char *) eopt + offset);
14591
14592 option->kind = BYTE_GET (eoption->kind);
14593 option->size = BYTE_GET (eoption->size);
14594 option->section = BYTE_GET (eoption->section);
14595 option->info = BYTE_GET (eoption->info);
14596
14597 /* PR 17531: file: ffa0fa3b. */
14598 if (option->size < sizeof (* eopt)
14599 || offset + option->size > sect->sh_size)
14600 {
14601 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14602 return 0;
14603 }
14604 offset += option->size;
14605
14606 ++option;
14607 ++cnt;
14608 }
14609
14610 printf (_("\nSection '%s' contains %d entries:\n"),
14611 printable_section_name (sect), cnt);
14612
14613 option = iopt;
14614 offset = 0;
14615
14616 while (cnt-- > 0)
14617 {
14618 size_t len;
14619
14620 switch (option->kind)
14621 {
14622 case ODK_NULL:
14623 /* This shouldn't happen. */
14624 printf (" NULL %d %lx", option->section, option->info);
14625 break;
14626 case ODK_REGINFO:
14627 printf (" REGINFO ");
14628 if (elf_header.e_machine == EM_MIPS)
14629 {
14630 /* 32bit form. */
14631 Elf32_External_RegInfo * ereg;
14632 Elf32_RegInfo reginfo;
14633
14634 ereg = (Elf32_External_RegInfo *) (option + 1);
14635 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14636 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14637 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14638 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14639 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14640 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14641
14642 printf ("GPR %08lx GP 0x%lx\n",
14643 reginfo.ri_gprmask,
14644 (unsigned long) reginfo.ri_gp_value);
14645 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14646 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14647 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14648 }
14649 else
14650 {
14651 /* 64 bit form. */
14652 Elf64_External_RegInfo * ereg;
14653 Elf64_Internal_RegInfo reginfo;
14654
14655 ereg = (Elf64_External_RegInfo *) (option + 1);
14656 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14657 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14658 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14659 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14660 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14661 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14662
14663 printf ("GPR %08lx GP 0x",
14664 reginfo.ri_gprmask);
14665 printf_vma (reginfo.ri_gp_value);
14666 printf ("\n");
14667
14668 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14669 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14670 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14671 }
14672 ++option;
14673 continue;
14674 case ODK_EXCEPTIONS:
14675 fputs (" EXCEPTIONS fpe_min(", stdout);
14676 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14677 fputs (") fpe_max(", stdout);
14678 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14679 fputs (")", stdout);
14680
14681 if (option->info & OEX_PAGE0)
14682 fputs (" PAGE0", stdout);
14683 if (option->info & OEX_SMM)
14684 fputs (" SMM", stdout);
14685 if (option->info & OEX_FPDBUG)
14686 fputs (" FPDBUG", stdout);
14687 if (option->info & OEX_DISMISS)
14688 fputs (" DISMISS", stdout);
14689 break;
14690 case ODK_PAD:
14691 fputs (" PAD ", stdout);
14692 if (option->info & OPAD_PREFIX)
14693 fputs (" PREFIX", stdout);
14694 if (option->info & OPAD_POSTFIX)
14695 fputs (" POSTFIX", stdout);
14696 if (option->info & OPAD_SYMBOL)
14697 fputs (" SYMBOL", stdout);
14698 break;
14699 case ODK_HWPATCH:
14700 fputs (" HWPATCH ", stdout);
14701 if (option->info & OHW_R4KEOP)
14702 fputs (" R4KEOP", stdout);
14703 if (option->info & OHW_R8KPFETCH)
14704 fputs (" R8KPFETCH", stdout);
14705 if (option->info & OHW_R5KEOP)
14706 fputs (" R5KEOP", stdout);
14707 if (option->info & OHW_R5KCVTL)
14708 fputs (" R5KCVTL", stdout);
14709 break;
14710 case ODK_FILL:
14711 fputs (" FILL ", stdout);
14712 /* XXX Print content of info word? */
14713 break;
14714 case ODK_TAGS:
14715 fputs (" TAGS ", stdout);
14716 /* XXX Print content of info word? */
14717 break;
14718 case ODK_HWAND:
14719 fputs (" HWAND ", stdout);
14720 if (option->info & OHWA0_R4KEOP_CHECKED)
14721 fputs (" R4KEOP_CHECKED", stdout);
14722 if (option->info & OHWA0_R4KEOP_CLEAN)
14723 fputs (" R4KEOP_CLEAN", stdout);
14724 break;
14725 case ODK_HWOR:
14726 fputs (" HWOR ", stdout);
14727 if (option->info & OHWA0_R4KEOP_CHECKED)
14728 fputs (" R4KEOP_CHECKED", stdout);
14729 if (option->info & OHWA0_R4KEOP_CLEAN)
14730 fputs (" R4KEOP_CLEAN", stdout);
14731 break;
14732 case ODK_GP_GROUP:
14733 printf (" GP_GROUP %#06lx self-contained %#06lx",
14734 option->info & OGP_GROUP,
14735 (option->info & OGP_SELF) >> 16);
14736 break;
14737 case ODK_IDENT:
14738 printf (" IDENT %#06lx self-contained %#06lx",
14739 option->info & OGP_GROUP,
14740 (option->info & OGP_SELF) >> 16);
14741 break;
14742 default:
14743 /* This shouldn't happen. */
14744 printf (" %3d ??? %d %lx",
14745 option->kind, option->section, option->info);
14746 break;
14747 }
14748
14749 len = sizeof (* eopt);
14750 while (len < option->size)
14751 {
14752 unsigned char datum = * ((unsigned char *) eopt + offset + len);
14753
14754 if (ISPRINT (datum))
14755 printf ("%c", datum);
14756 else
14757 printf ("\\%03o", datum);
14758 len ++;
14759 }
14760 fputs ("\n", stdout);
14761
14762 offset += option->size;
14763 ++option;
14764 }
14765
14766 free (eopt);
14767 }
14768 }
14769
14770 if (conflicts_offset != 0 && conflictsno != 0)
14771 {
14772 Elf32_Conflict * iconf;
14773 size_t cnt;
14774
14775 if (dynamic_symbols == NULL)
14776 {
14777 error (_("conflict list found without a dynamic symbol table\n"));
14778 return 0;
14779 }
14780
14781 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14782 if (iconf == NULL)
14783 {
14784 error (_("Out of memory allocating space for dynamic conflicts\n"));
14785 return 0;
14786 }
14787
14788 if (is_32bit_elf)
14789 {
14790 Elf32_External_Conflict * econf32;
14791
14792 econf32 = (Elf32_External_Conflict *)
14793 get_data (NULL, file, conflicts_offset, conflictsno,
14794 sizeof (* econf32), _("conflict"));
14795 if (!econf32)
14796 return 0;
14797
14798 for (cnt = 0; cnt < conflictsno; ++cnt)
14799 iconf[cnt] = BYTE_GET (econf32[cnt]);
14800
14801 free (econf32);
14802 }
14803 else
14804 {
14805 Elf64_External_Conflict * econf64;
14806
14807 econf64 = (Elf64_External_Conflict *)
14808 get_data (NULL, file, conflicts_offset, conflictsno,
14809 sizeof (* econf64), _("conflict"));
14810 if (!econf64)
14811 return 0;
14812
14813 for (cnt = 0; cnt < conflictsno; ++cnt)
14814 iconf[cnt] = BYTE_GET (econf64[cnt]);
14815
14816 free (econf64);
14817 }
14818
14819 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14820 (unsigned long) conflictsno);
14821 puts (_(" Num: Index Value Name"));
14822
14823 for (cnt = 0; cnt < conflictsno; ++cnt)
14824 {
14825 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
14826
14827 if (iconf[cnt] >= num_dynamic_syms)
14828 printf (_("<corrupt symbol index>"));
14829 else
14830 {
14831 Elf_Internal_Sym * psym;
14832
14833 psym = & dynamic_symbols[iconf[cnt]];
14834 print_vma (psym->st_value, FULL_HEX);
14835 putchar (' ');
14836 if (VALID_DYNAMIC_NAME (psym->st_name))
14837 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14838 else
14839 printf (_("<corrupt: %14ld>"), psym->st_name);
14840 }
14841 putchar ('\n');
14842 }
14843
14844 free (iconf);
14845 }
14846
14847 if (pltgot != 0 && local_gotno != 0)
14848 {
14849 bfd_vma ent, local_end, global_end;
14850 size_t i, offset;
14851 unsigned char * data;
14852 unsigned char * data_end;
14853 int addr_size;
14854
14855 ent = pltgot;
14856 addr_size = (is_32bit_elf ? 4 : 8);
14857 local_end = pltgot + local_gotno * addr_size;
14858
14859 /* PR binutils/17533 file: 012-111227-0.004 */
14860 if (symtabno < gotsym)
14861 {
14862 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14863 (unsigned long) gotsym, (unsigned long) symtabno);
14864 return 0;
14865 }
14866
14867 global_end = local_end + (symtabno - gotsym) * addr_size;
14868 /* PR 17531: file: 54c91a34. */
14869 if (global_end < local_end)
14870 {
14871 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14872 return 0;
14873 }
14874
14875 offset = offset_from_vma (file, pltgot, global_end - pltgot);
14876 data = (unsigned char *) get_data (NULL, file, offset,
14877 global_end - pltgot, 1,
14878 _("Global Offset Table data"));
14879 if (data == NULL)
14880 return 0;
14881 data_end = data + (global_end - pltgot);
14882
14883 printf (_("\nPrimary GOT:\n"));
14884 printf (_(" Canonical gp value: "));
14885 print_vma (pltgot + 0x7ff0, LONG_HEX);
14886 printf ("\n\n");
14887
14888 printf (_(" Reserved entries:\n"));
14889 printf (_(" %*s %10s %*s Purpose\n"),
14890 addr_size * 2, _("Address"), _("Access"),
14891 addr_size * 2, _("Initial"));
14892 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14893 printf (_(" Lazy resolver\n"));
14894 if (ent == (bfd_vma) -1)
14895 goto got_print_fail;
14896 if (data
14897 && (byte_get (data + ent - pltgot, addr_size)
14898 >> (addr_size * 8 - 1)) != 0)
14899 {
14900 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14901 printf (_(" Module pointer (GNU extension)\n"));
14902 if (ent == (bfd_vma) -1)
14903 goto got_print_fail;
14904 }
14905 printf ("\n");
14906
14907 if (ent < local_end)
14908 {
14909 printf (_(" Local entries:\n"));
14910 printf (" %*s %10s %*s\n",
14911 addr_size * 2, _("Address"), _("Access"),
14912 addr_size * 2, _("Initial"));
14913 while (ent < local_end)
14914 {
14915 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14916 printf ("\n");
14917 if (ent == (bfd_vma) -1)
14918 goto got_print_fail;
14919 }
14920 printf ("\n");
14921 }
14922
14923 if (gotsym < symtabno)
14924 {
14925 int sym_width;
14926
14927 printf (_(" Global entries:\n"));
14928 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14929 addr_size * 2, _("Address"),
14930 _("Access"),
14931 addr_size * 2, _("Initial"),
14932 addr_size * 2, _("Sym.Val."),
14933 _("Type"),
14934 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14935 _("Ndx"), _("Name"));
14936
14937 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14938
14939 for (i = gotsym; i < symtabno; i++)
14940 {
14941 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14942 printf (" ");
14943
14944 if (dynamic_symbols == NULL)
14945 printf (_("<no dynamic symbols>"));
14946 else if (i < num_dynamic_syms)
14947 {
14948 Elf_Internal_Sym * psym = dynamic_symbols + i;
14949
14950 print_vma (psym->st_value, LONG_HEX);
14951 printf (" %-7s %3s ",
14952 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14953 get_symbol_index_type (psym->st_shndx));
14954
14955 if (VALID_DYNAMIC_NAME (psym->st_name))
14956 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14957 else
14958 printf (_("<corrupt: %14ld>"), psym->st_name);
14959 }
14960 else
14961 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14962 (unsigned long) i);
14963
14964 printf ("\n");
14965 if (ent == (bfd_vma) -1)
14966 break;
14967 }
14968 printf ("\n");
14969 }
14970
14971 got_print_fail:
14972 if (data)
14973 free (data);
14974 }
14975
14976 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14977 {
14978 bfd_vma ent, end;
14979 size_t offset, rel_offset;
14980 unsigned long count, i;
14981 unsigned char * data;
14982 int addr_size, sym_width;
14983 Elf_Internal_Rela * rels;
14984
14985 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14986 if (pltrel == DT_RELA)
14987 {
14988 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14989 return 0;
14990 }
14991 else
14992 {
14993 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14994 return 0;
14995 }
14996
14997 ent = mips_pltgot;
14998 addr_size = (is_32bit_elf ? 4 : 8);
14999 end = mips_pltgot + (2 + count) * addr_size;
15000
15001 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15002 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15003 1, _("Procedure Linkage Table data"));
15004 if (data == NULL)
15005 return 0;
15006
15007 printf ("\nPLT GOT:\n\n");
15008 printf (_(" Reserved entries:\n"));
15009 printf (_(" %*s %*s Purpose\n"),
15010 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15011 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15012 printf (_(" PLT lazy resolver\n"));
15013 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15014 printf (_(" Module pointer\n"));
15015 printf ("\n");
15016
15017 printf (_(" Entries:\n"));
15018 printf (" %*s %*s %*s %-7s %3s %s\n",
15019 addr_size * 2, _("Address"),
15020 addr_size * 2, _("Initial"),
15021 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15022 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15023 for (i = 0; i < count; i++)
15024 {
15025 unsigned long idx = get_reloc_symindex (rels[i].r_info);
15026
15027 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15028 printf (" ");
15029
15030 if (idx >= num_dynamic_syms)
15031 printf (_("<corrupt symbol index: %lu>"), idx);
15032 else
15033 {
15034 Elf_Internal_Sym * psym = dynamic_symbols + idx;
15035
15036 print_vma (psym->st_value, LONG_HEX);
15037 printf (" %-7s %3s ",
15038 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15039 get_symbol_index_type (psym->st_shndx));
15040 if (VALID_DYNAMIC_NAME (psym->st_name))
15041 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15042 else
15043 printf (_("<corrupt: %14ld>"), psym->st_name);
15044 }
15045 printf ("\n");
15046 }
15047 printf ("\n");
15048
15049 if (data)
15050 free (data);
15051 free (rels);
15052 }
15053
15054 return 1;
15055}
15056
15057static int
15058process_nds32_specific (FILE * file)
15059{
15060 Elf_Internal_Shdr *sect = NULL;
15061
15062 sect = find_section (".nds32_e_flags");
15063 if (sect != NULL)
15064 {
15065 unsigned int *flag;
15066
15067 printf ("\nNDS32 elf flags section:\n");
15068 flag = get_data (NULL, file, sect->sh_offset, 1,
15069 sect->sh_size, _("NDS32 elf flags section"));
15070
15071 switch ((*flag) & 0x3)
15072 {
15073 case 0:
15074 printf ("(VEC_SIZE):\tNo entry.\n");
15075 break;
15076 case 1:
15077 printf ("(VEC_SIZE):\t4 bytes\n");
15078 break;
15079 case 2:
15080 printf ("(VEC_SIZE):\t16 bytes\n");
15081 break;
15082 case 3:
15083 printf ("(VEC_SIZE):\treserved\n");
15084 break;
15085 }
15086 }
15087
15088 return TRUE;
15089}
15090
15091static int
15092process_gnu_liblist (FILE * file)
15093{
15094 Elf_Internal_Shdr * section;
15095 Elf_Internal_Shdr * string_sec;
15096 Elf32_External_Lib * elib;
15097 char * strtab;
15098 size_t strtab_size;
15099 size_t cnt;
15100 unsigned i;
15101
15102 if (! do_arch)
15103 return 0;
15104
15105 for (i = 0, section = section_headers;
15106 i < elf_header.e_shnum;
15107 i++, section++)
15108 {
15109 switch (section->sh_type)
15110 {
15111 case SHT_GNU_LIBLIST:
15112 if (section->sh_link >= elf_header.e_shnum)
15113 break;
15114
15115 elib = (Elf32_External_Lib *)
15116 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
15117 _("liblist section data"));
15118
15119 if (elib == NULL)
15120 break;
15121 string_sec = section_headers + section->sh_link;
15122
15123 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15124 string_sec->sh_size,
15125 _("liblist string table"));
15126 if (strtab == NULL
15127 || section->sh_entsize != sizeof (Elf32_External_Lib))
15128 {
15129 free (elib);
15130 free (strtab);
15131 break;
15132 }
15133 strtab_size = string_sec->sh_size;
15134
15135 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15136 printable_section_name (section),
15137 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
15138
15139 puts (_(" Library Time Stamp Checksum Version Flags"));
15140
15141 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15142 ++cnt)
15143 {
15144 Elf32_Lib liblist;
15145 time_t atime;
15146 char timebuf[128];
15147 struct tm * tmp;
15148
15149 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15150 atime = BYTE_GET (elib[cnt].l_time_stamp);
15151 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15152 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15153 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15154
15155 tmp = gmtime (&atime);
15156 snprintf (timebuf, sizeof (timebuf),
15157 "%04u-%02u-%02uT%02u:%02u:%02u",
15158 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15159 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15160
15161 printf ("%3lu: ", (unsigned long) cnt);
15162 if (do_wide)
15163 printf ("%-20s", liblist.l_name < strtab_size
15164 ? strtab + liblist.l_name : _("<corrupt>"));
15165 else
15166 printf ("%-20.20s", liblist.l_name < strtab_size
15167 ? strtab + liblist.l_name : _("<corrupt>"));
15168 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15169 liblist.l_version, liblist.l_flags);
15170 }
15171
15172 free (elib);
15173 free (strtab);
15174 }
15175 }
15176
15177 return 1;
15178}
15179
15180static const char *
15181get_note_type (unsigned e_type)
15182{
15183 static char buff[64];
15184
15185 if (elf_header.e_type == ET_CORE)
15186 switch (e_type)
15187 {
15188 case NT_AUXV:
15189 return _("NT_AUXV (auxiliary vector)");
15190 case NT_PRSTATUS:
15191 return _("NT_PRSTATUS (prstatus structure)");
15192 case NT_FPREGSET:
15193 return _("NT_FPREGSET (floating point registers)");
15194 case NT_PRPSINFO:
15195 return _("NT_PRPSINFO (prpsinfo structure)");
15196 case NT_TASKSTRUCT:
15197 return _("NT_TASKSTRUCT (task structure)");
15198 case NT_PRXFPREG:
15199 return _("NT_PRXFPREG (user_xfpregs structure)");
15200 case NT_PPC_VMX:
15201 return _("NT_PPC_VMX (ppc Altivec registers)");
15202 case NT_PPC_VSX:
15203 return _("NT_PPC_VSX (ppc VSX registers)");
15204 case NT_386_TLS:
15205 return _("NT_386_TLS (x86 TLS information)");
15206 case NT_386_IOPERM:
15207 return _("NT_386_IOPERM (x86 I/O permissions)");
15208 case NT_X86_XSTATE:
15209 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15210 case NT_S390_HIGH_GPRS:
15211 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15212 case NT_S390_TIMER:
15213 return _("NT_S390_TIMER (s390 timer register)");
15214 case NT_S390_TODCMP:
15215 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15216 case NT_S390_TODPREG:
15217 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15218 case NT_S390_CTRS:
15219 return _("NT_S390_CTRS (s390 control registers)");
15220 case NT_S390_PREFIX:
15221 return _("NT_S390_PREFIX (s390 prefix register)");
15222 case NT_S390_LAST_BREAK:
15223 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15224 case NT_S390_SYSTEM_CALL:
15225 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15226 case NT_S390_TDB:
15227 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15228 case NT_S390_VXRS_LOW:
15229 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15230 case NT_S390_VXRS_HIGH:
15231 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15232 case NT_ARM_VFP:
15233 return _("NT_ARM_VFP (arm VFP registers)");
15234 case NT_ARM_TLS:
15235 return _("NT_ARM_TLS (AArch TLS registers)");
15236 case NT_ARM_HW_BREAK:
15237 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15238 case NT_ARM_HW_WATCH:
15239 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15240 case NT_PSTATUS:
15241 return _("NT_PSTATUS (pstatus structure)");
15242 case NT_FPREGS:
15243 return _("NT_FPREGS (floating point registers)");
15244 case NT_PSINFO:
15245 return _("NT_PSINFO (psinfo structure)");
15246 case NT_LWPSTATUS:
15247 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15248 case NT_LWPSINFO:
15249 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15250 case NT_WIN32PSTATUS:
15251 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15252 case NT_SIGINFO:
15253 return _("NT_SIGINFO (siginfo_t data)");
15254 case NT_FILE:
15255 return _("NT_FILE (mapped files)");
15256 default:
15257 break;
15258 }
15259 else
15260 switch (e_type)
15261 {
15262 case NT_VERSION:
15263 return _("NT_VERSION (version)");
15264 case NT_ARCH:
15265 return _("NT_ARCH (architecture)");
15266 default:
15267 break;
15268 }
15269
15270 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15271 return buff;
15272}
15273
15274static int
15275print_core_note (Elf_Internal_Note *pnote)
15276{
15277 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15278 bfd_vma count, page_size;
15279 unsigned char *descdata, *filenames, *descend;
15280
15281 if (pnote->type != NT_FILE)
15282 return 1;
15283
15284#ifndef BFD64
15285 if (!is_32bit_elf)
15286 {
15287 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15288 /* Still "successful". */
15289 return 1;
15290 }
15291#endif
15292
15293 if (pnote->descsz < 2 * addr_size)
15294 {
15295 printf (_(" Malformed note - too short for header\n"));
15296 return 0;
15297 }
15298
15299 descdata = (unsigned char *) pnote->descdata;
15300 descend = descdata + pnote->descsz;
15301
15302 if (descdata[pnote->descsz - 1] != '\0')
15303 {
15304 printf (_(" Malformed note - does not end with \\0\n"));
15305 return 0;
15306 }
15307
15308 count = byte_get (descdata, addr_size);
15309 descdata += addr_size;
15310
15311 page_size = byte_get (descdata, addr_size);
15312 descdata += addr_size;
15313
15314 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15315 {
15316 printf (_(" Malformed note - too short for supplied file count\n"));
15317 return 0;
15318 }
15319
15320 printf (_(" Page size: "));
15321 print_vma (page_size, DEC);
15322 printf ("\n");
15323
15324 printf (_(" %*s%*s%*s\n"),
15325 (int) (2 + 2 * addr_size), _("Start"),
15326 (int) (4 + 2 * addr_size), _("End"),
15327 (int) (4 + 2 * addr_size), _("Page Offset"));
15328 filenames = descdata + count * 3 * addr_size;
15329 while (count-- > 0)
15330 {
15331 bfd_vma start, end, file_ofs;
15332
15333 if (filenames == descend)
15334 {
15335 printf (_(" Malformed note - filenames end too early\n"));
15336 return 0;
15337 }
15338
15339 start = byte_get (descdata, addr_size);
15340 descdata += addr_size;
15341 end = byte_get (descdata, addr_size);
15342 descdata += addr_size;
15343 file_ofs = byte_get (descdata, addr_size);
15344 descdata += addr_size;
15345
15346 printf (" ");
15347 print_vma (start, FULL_HEX);
15348 printf (" ");
15349 print_vma (end, FULL_HEX);
15350 printf (" ");
15351 print_vma (file_ofs, FULL_HEX);
15352 printf ("\n %s\n", filenames);
15353
15354 filenames += 1 + strlen ((char *) filenames);
15355 }
15356
15357 return 1;
15358}
15359
15360static const char *
15361get_gnu_elf_note_type (unsigned e_type)
15362{
15363 static char buff[64];
15364
15365 switch (e_type)
15366 {
15367 case NT_GNU_ABI_TAG:
15368 return _("NT_GNU_ABI_TAG (ABI version tag)");
15369 case NT_GNU_HWCAP:
15370 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15371 case NT_GNU_BUILD_ID:
15372 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15373 case NT_GNU_GOLD_VERSION:
15374 return _("NT_GNU_GOLD_VERSION (gold version)");
15375 default:
15376 break;
15377 }
15378
15379 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15380 return buff;
15381}
15382
15383static int
15384print_gnu_note (Elf_Internal_Note *pnote)
15385{
15386 switch (pnote->type)
15387 {
15388 case NT_GNU_BUILD_ID:
15389 {
15390 unsigned long i;
15391
15392 printf (_(" Build ID: "));
15393 for (i = 0; i < pnote->descsz; ++i)
15394 printf ("%02x", pnote->descdata[i] & 0xff);
15395 printf ("\n");
15396 }
15397 break;
15398
15399 case NT_GNU_ABI_TAG:
15400 {
15401 unsigned long os, major, minor, subminor;
15402 const char *osname;
15403
15404 /* PR 17531: file: 030-599401-0.004. */
15405 if (pnote->descsz < 16)
15406 {
15407 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15408 break;
15409 }
15410
15411 os = byte_get ((unsigned char *) pnote->descdata, 4);
15412 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15413 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15414 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15415
15416 switch (os)
15417 {
15418 case GNU_ABI_TAG_LINUX:
15419 osname = "Linux";
15420 break;
15421 case GNU_ABI_TAG_HURD:
15422 osname = "Hurd";
15423 break;
15424 case GNU_ABI_TAG_SOLARIS:
15425 osname = "Solaris";
15426 break;
15427 case GNU_ABI_TAG_FREEBSD:
15428 osname = "FreeBSD";
15429 break;
15430 case GNU_ABI_TAG_NETBSD:
15431 osname = "NetBSD";
15432 break;
15433 case GNU_ABI_TAG_SYLLABLE:
15434 osname = "Syllable";
15435 break;
15436 case GNU_ABI_TAG_NACL:
15437 osname = "NaCl";
15438 break;
15439 default:
15440 osname = "Unknown";
15441 break;
15442 }
15443
15444 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15445 major, minor, subminor);
15446 }
15447 break;
15448
15449 case NT_GNU_GOLD_VERSION:
15450 {
15451 unsigned long i;
15452
15453 printf (_(" Version: "));
15454 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15455 printf ("%c", pnote->descdata[i]);
15456 printf ("\n");
15457 }
15458 break;
15459 }
15460
15461 return 1;
15462}
15463
15464static const char *
15465get_v850_elf_note_type (enum v850_notes n_type)
15466{
15467 static char buff[64];
15468
15469 switch (n_type)
15470 {
15471 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15472 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15473 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15474 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15475 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15476 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15477 default:
15478 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15479 return buff;
15480 }
15481}
15482
15483static int
15484print_v850_note (Elf_Internal_Note * pnote)
15485{
15486 unsigned int val;
15487
15488 if (pnote->descsz != 4)
15489 return 0;
15490 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15491
15492 if (val == 0)
15493 {
15494 printf (_("not set\n"));
15495 return 1;
15496 }
15497
15498 switch (pnote->type)
15499 {
15500 case V850_NOTE_ALIGNMENT:
15501 switch (val)
15502 {
15503 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15504 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15505 }
15506 break;
15507
15508 case V850_NOTE_DATA_SIZE:
15509 switch (val)
15510 {
15511 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15512 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15513 }
15514 break;
15515
15516 case V850_NOTE_FPU_INFO:
15517 switch (val)
15518 {
15519 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15520 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15521 }
15522 break;
15523
15524 case V850_NOTE_MMU_INFO:
15525 case V850_NOTE_CACHE_INFO:
15526 case V850_NOTE_SIMD_INFO:
15527 if (val == EF_RH850_SIMD)
15528 {
15529 printf (_("yes\n"));
15530 return 1;
15531 }
15532 break;
15533
15534 default:
15535 /* An 'unknown note type' message will already have been displayed. */
15536 break;
15537 }
15538
15539 printf (_("unknown value: %x\n"), val);
15540 return 0;
15541}
15542
15543static int
15544process_netbsd_elf_note (Elf_Internal_Note * pnote)
15545{
15546 unsigned int version;
15547
15548 switch (pnote->type)
15549 {
15550 case NT_NETBSD_IDENT:
15551 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15552 if ((version / 10000) % 100)
15553 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15554 version, version / 100000000, (version / 1000000) % 100,
15555 (version / 10000) % 100 > 26 ? "Z" : "",
15556 'A' + (version / 10000) % 26);
15557 else
15558 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15559 version, version / 100000000, (version / 1000000) % 100,
15560 (version / 100) % 100);
15561 return 1;
15562
15563 case NT_NETBSD_MARCH:
15564 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15565 pnote->descdata);
15566 return 1;
15567
15568 default:
15569 break;
15570 }
15571
15572 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15573 pnote->type);
15574 return 1;
15575}
15576
15577static const char *
15578get_freebsd_elfcore_note_type (unsigned e_type)
15579{
15580 switch (e_type)
15581 {
15582 case NT_FREEBSD_THRMISC:
15583 return _("NT_THRMISC (thrmisc structure)");
15584 case NT_FREEBSD_PROCSTAT_PROC:
15585 return _("NT_PROCSTAT_PROC (proc data)");
15586 case NT_FREEBSD_PROCSTAT_FILES:
15587 return _("NT_PROCSTAT_FILES (files data)");
15588 case NT_FREEBSD_PROCSTAT_VMMAP:
15589 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15590 case NT_FREEBSD_PROCSTAT_GROUPS:
15591 return _("NT_PROCSTAT_GROUPS (groups data)");
15592 case NT_FREEBSD_PROCSTAT_UMASK:
15593 return _("NT_PROCSTAT_UMASK (umask data)");
15594 case NT_FREEBSD_PROCSTAT_RLIMIT:
15595 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15596 case NT_FREEBSD_PROCSTAT_OSREL:
15597 return _("NT_PROCSTAT_OSREL (osreldate data)");
15598 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15599 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15600 case NT_FREEBSD_PROCSTAT_AUXV:
15601 return _("NT_PROCSTAT_AUXV (auxv data)");
15602 }
15603 return get_note_type (e_type);
15604}
15605
15606static const char *
15607get_netbsd_elfcore_note_type (unsigned e_type)
15608{
15609 static char buff[64];
15610
15611 if (e_type == NT_NETBSDCORE_PROCINFO)
15612 {
15613 /* NetBSD core "procinfo" structure. */
15614 return _("NetBSD procinfo structure");
15615 }
15616
15617 /* As of Jan 2002 there are no other machine-independent notes
15618 defined for NetBSD core files. If the note type is less
15619 than the start of the machine-dependent note types, we don't
15620 understand it. */
15621
15622 if (e_type < NT_NETBSDCORE_FIRSTMACH)
15623 {
15624 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15625 return buff;
15626 }
15627
15628 switch (elf_header.e_machine)
15629 {
15630 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15631 and PT_GETFPREGS == mach+2. */
15632
15633 case EM_OLD_ALPHA:
15634 case EM_ALPHA:
15635 case EM_SPARC:
15636 case EM_SPARC32PLUS:
15637 case EM_SPARCV9:
15638 switch (e_type)
15639 {
15640 case NT_NETBSDCORE_FIRSTMACH + 0:
15641 return _("PT_GETREGS (reg structure)");
15642 case NT_NETBSDCORE_FIRSTMACH + 2:
15643 return _("PT_GETFPREGS (fpreg structure)");
15644 default:
15645 break;
15646 }
15647 break;
15648
15649 /* On all other arch's, PT_GETREGS == mach+1 and
15650 PT_GETFPREGS == mach+3. */
15651 default:
15652 switch (e_type)
15653 {
15654 case NT_NETBSDCORE_FIRSTMACH + 1:
15655 return _("PT_GETREGS (reg structure)");
15656 case NT_NETBSDCORE_FIRSTMACH + 3:
15657 return _("PT_GETFPREGS (fpreg structure)");
15658 default:
15659 break;
15660 }
15661 }
15662
15663 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15664 e_type - NT_NETBSDCORE_FIRSTMACH);
15665 return buff;
15666}
15667
15668static const char *
15669get_stapsdt_note_type (unsigned e_type)
15670{
15671 static char buff[64];
15672
15673 switch (e_type)
15674 {
15675 case NT_STAPSDT:
15676 return _("NT_STAPSDT (SystemTap probe descriptors)");
15677
15678 default:
15679 break;
15680 }
15681
15682 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15683 return buff;
15684}
15685
15686static int
15687print_stapsdt_note (Elf_Internal_Note *pnote)
15688{
15689 int addr_size = is_32bit_elf ? 4 : 8;
15690 char *data = pnote->descdata;
15691 char *data_end = pnote->descdata + pnote->descsz;
15692 bfd_vma pc, base_addr, semaphore;
15693 char *provider, *probe, *arg_fmt;
15694
15695 pc = byte_get ((unsigned char *) data, addr_size);
15696 data += addr_size;
15697 base_addr = byte_get ((unsigned char *) data, addr_size);
15698 data += addr_size;
15699 semaphore = byte_get ((unsigned char *) data, addr_size);
15700 data += addr_size;
15701
15702 provider = data;
15703 data += strlen (data) + 1;
15704 probe = data;
15705 data += strlen (data) + 1;
15706 arg_fmt = data;
15707 data += strlen (data) + 1;
15708
15709 printf (_(" Provider: %s\n"), provider);
15710 printf (_(" Name: %s\n"), probe);
15711 printf (_(" Location: "));
15712 print_vma (pc, FULL_HEX);
15713 printf (_(", Base: "));
15714 print_vma (base_addr, FULL_HEX);
15715 printf (_(", Semaphore: "));
15716 print_vma (semaphore, FULL_HEX);
15717 printf ("\n");
15718 printf (_(" Arguments: %s\n"), arg_fmt);
15719
15720 return data == data_end;
15721}
15722
15723static const char *
15724get_ia64_vms_note_type (unsigned e_type)
15725{
15726 static char buff[64];
15727
15728 switch (e_type)
15729 {
15730 case NT_VMS_MHD:
15731 return _("NT_VMS_MHD (module header)");
15732 case NT_VMS_LNM:
15733 return _("NT_VMS_LNM (language name)");
15734 case NT_VMS_SRC:
15735 return _("NT_VMS_SRC (source files)");
15736 case NT_VMS_TITLE:
15737 return "NT_VMS_TITLE";
15738 case NT_VMS_EIDC:
15739 return _("NT_VMS_EIDC (consistency check)");
15740 case NT_VMS_FPMODE:
15741 return _("NT_VMS_FPMODE (FP mode)");
15742 case NT_VMS_LINKTIME:
15743 return "NT_VMS_LINKTIME";
15744 case NT_VMS_IMGNAM:
15745 return _("NT_VMS_IMGNAM (image name)");
15746 case NT_VMS_IMGID:
15747 return _("NT_VMS_IMGID (image id)");
15748 case NT_VMS_LINKID:
15749 return _("NT_VMS_LINKID (link id)");
15750 case NT_VMS_IMGBID:
15751 return _("NT_VMS_IMGBID (build id)");
15752 case NT_VMS_GSTNAM:
15753 return _("NT_VMS_GSTNAM (sym table name)");
15754 case NT_VMS_ORIG_DYN:
15755 return "NT_VMS_ORIG_DYN";
15756 case NT_VMS_PATCHTIME:
15757 return "NT_VMS_PATCHTIME";
15758 default:
15759 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15760 return buff;
15761 }
15762}
15763
15764static int
15765print_ia64_vms_note (Elf_Internal_Note * pnote)
15766{
15767 switch (pnote->type)
15768 {
15769 case NT_VMS_MHD:
15770 if (pnote->descsz > 36)
15771 {
15772 size_t l = strlen (pnote->descdata + 34);
15773 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15774 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15775 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15776 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15777 }
15778 else
15779 printf (_(" Invalid size\n"));
15780 break;
15781 case NT_VMS_LNM:
15782 printf (_(" Language: %s\n"), pnote->descdata);
15783 break;
15784#ifdef BFD64
15785 case NT_VMS_FPMODE:
15786 printf (_(" Floating Point mode: "));
15787 printf ("0x%016" BFD_VMA_FMT "x\n",
15788 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
15789 break;
15790 case NT_VMS_LINKTIME:
15791 printf (_(" Link time: "));
15792 print_vms_time
15793 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15794 printf ("\n");
15795 break;
15796 case NT_VMS_PATCHTIME:
15797 printf (_(" Patch time: "));
15798 print_vms_time
15799 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15800 printf ("\n");
15801 break;
15802 case NT_VMS_ORIG_DYN:
15803 printf (_(" Major id: %u, minor id: %u\n"),
15804 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15805 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15806 printf (_(" Last modified : "));
15807 print_vms_time
15808 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15809 printf (_("\n Link flags : "));
15810 printf ("0x%016" BFD_VMA_FMT "x\n",
15811 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15812 printf (_(" Header flags: 0x%08x\n"),
15813 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15814 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15815 break;
15816#endif
15817 case NT_VMS_IMGNAM:
15818 printf (_(" Image name: %s\n"), pnote->descdata);
15819 break;
15820 case NT_VMS_GSTNAM:
15821 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15822 break;
15823 case NT_VMS_IMGID:
15824 printf (_(" Image id: %s\n"), pnote->descdata);
15825 break;
15826 case NT_VMS_LINKID:
15827 printf (_(" Linker id: %s\n"), pnote->descdata);
15828 break;
15829 default:
15830 break;
15831 }
15832 return 1;
15833}
15834
15835/* Note that by the ELF standard, the name field is already null byte
15836 terminated, and namesz includes the terminating null byte.
15837 I.E. the value of namesz for the name "FSF" is 4.
15838
15839 If the value of namesz is zero, there is no name present. */
15840static int
15841process_note (Elf_Internal_Note * pnote)
15842{
15843 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15844 const char * nt;
15845
15846 if (pnote->namesz == 0)
15847 /* If there is no note name, then use the default set of
15848 note type strings. */
15849 nt = get_note_type (pnote->type);
15850
15851 else if (const_strneq (pnote->namedata, "GNU"))
15852 /* GNU-specific object file notes. */
15853 nt = get_gnu_elf_note_type (pnote->type);
15854
15855 else if (const_strneq (pnote->namedata, "FreeBSD"))
15856 /* FreeBSD-specific core file notes. */
15857 nt = get_freebsd_elfcore_note_type (pnote->type);
15858
15859 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15860 /* NetBSD-specific core file notes. */
15861 nt = get_netbsd_elfcore_note_type (pnote->type);
15862
15863 else if (const_strneq (pnote->namedata, "NetBSD"))
15864 /* NetBSD-specific core file notes. */
15865 return process_netbsd_elf_note (pnote);
15866
15867 else if (strneq (pnote->namedata, "SPU/", 4))
15868 {
15869 /* SPU-specific core file notes. */
15870 nt = pnote->namedata + 4;
15871 name = "SPU";
15872 }
15873
15874 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15875 /* VMS/ia64-specific file notes. */
15876 nt = get_ia64_vms_note_type (pnote->type);
15877
15878 else if (const_strneq (pnote->namedata, "stapsdt"))
15879 nt = get_stapsdt_note_type (pnote->type);
15880
15881 else
15882 /* Don't recognize this note name; just use the default set of
15883 note type strings. */
15884 nt = get_note_type (pnote->type);
15885
15886 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15887
15888 if (const_strneq (pnote->namedata, "IPF/VMS"))
15889 return print_ia64_vms_note (pnote);
15890 else if (const_strneq (pnote->namedata, "GNU"))
15891 return print_gnu_note (pnote);
15892 else if (const_strneq (pnote->namedata, "stapsdt"))
15893 return print_stapsdt_note (pnote);
15894 else if (const_strneq (pnote->namedata, "CORE"))
15895 return print_core_note (pnote);
15896 else
15897 return 1;
15898}
15899
15900
15901static int
15902process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15903{
15904 Elf_External_Note * pnotes;
15905 Elf_External_Note * external;
15906 char * end;
15907 int res = 1;
15908
15909 if (length <= 0)
15910 return 0;
15911
15912 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15913 _("notes"));
15914 if (pnotes == NULL)
15915 return 0;
15916
15917 external = pnotes;
15918
15919 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15920 (unsigned long) offset, (unsigned long) length);
15921 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15922
15923 end = (char *) pnotes + length;
15924 while ((char *) external < end)
15925 {
15926 Elf_Internal_Note inote;
15927 size_t min_notesz;
15928 char *next;
15929 char * temp = NULL;
15930 size_t data_remaining = end - (char *) external;
15931
15932 if (!is_ia64_vms ())
15933 {
15934 /* PR binutils/15191
15935 Make sure that there is enough data to read. */
15936 min_notesz = offsetof (Elf_External_Note, name);
15937 if (data_remaining < min_notesz)
15938 {
15939 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15940 (int) data_remaining);
15941 break;
15942 }
15943 inote.type = BYTE_GET (external->type);
15944 inote.namesz = BYTE_GET (external->namesz);
15945 inote.namedata = external->name;
15946 inote.descsz = BYTE_GET (external->descsz);
15947 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15948 /* PR 17531: file: 3443835e. */
15949 if (inote.descdata < (char *) pnotes || inote.descdata > end)
15950 {
15951 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15952 inote.descdata = inote.namedata;
15953 inote.namesz = 0;
15954 }
15955
15956 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15957 next = inote.descdata + align_power (inote.descsz, 2);
15958 }
15959 else
15960 {
15961 Elf64_External_VMS_Note *vms_external;
15962
15963 /* PR binutils/15191
15964 Make sure that there is enough data to read. */
15965 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15966 if (data_remaining < min_notesz)
15967 {
15968 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15969 (int) data_remaining);
15970 break;
15971 }
15972
15973 vms_external = (Elf64_External_VMS_Note *) external;
15974 inote.type = BYTE_GET (vms_external->type);
15975 inote.namesz = BYTE_GET (vms_external->namesz);
15976 inote.namedata = vms_external->name;
15977 inote.descsz = BYTE_GET (vms_external->descsz);
15978 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15979 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15980 next = inote.descdata + align_power (inote.descsz, 3);
15981 }
15982
15983 if (inote.descdata < (char *) external + min_notesz
15984 || next < (char *) external + min_notesz
15985 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15986 || inote.namedata + inote.namesz < inote.namedata
15987 || inote.descdata + inote.descsz < inote.descdata
15988 || data_remaining < (size_t)(next - (char *) external))
15989 {
15990 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15991 (unsigned long) ((char *) external - (char *) pnotes));
15992 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15993 inote.type, inote.namesz, inote.descsz);
15994 break;
15995 }
15996
15997 external = (Elf_External_Note *) next;
15998
15999 /* Verify that name is null terminated. It appears that at least
16000 one version of Linux (RedHat 6.0) generates corefiles that don't
16001 comply with the ELF spec by failing to include the null byte in
16002 namesz. */
16003 if (inote.namedata[inote.namesz - 1] != '\0')
16004 {
16005 temp = (char *) malloc (inote.namesz + 1);
16006 if (temp == NULL)
16007 {
16008 error (_("Out of memory allocating space for inote name\n"));
16009 res = 0;
16010 break;
16011 }
16012
16013 strncpy (temp, inote.namedata, inote.namesz);
16014 temp[inote.namesz] = 0;
16015
16016 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16017 inote.namedata = temp;
16018 }
16019
16020 res &= process_note (& inote);
16021
16022 if (temp != NULL)
16023 {
16024 free (temp);
16025 temp = NULL;
16026 }
16027 }
16028
16029 free (pnotes);
16030
16031 return res;
16032}
16033
16034static int
16035process_corefile_note_segments (FILE * file)
16036{
16037 Elf_Internal_Phdr * segment;
16038 unsigned int i;
16039 int res = 1;
16040
16041 if (! get_program_headers (file))
16042 return 0;
16043
16044 for (i = 0, segment = program_headers;
16045 i < elf_header.e_phnum;
16046 i++, segment++)
16047 {
16048 if (segment->p_type == PT_NOTE)
16049 res &= process_corefile_note_segment (file,
16050 (bfd_vma) segment->p_offset,
16051 (bfd_vma) segment->p_filesz);
16052 }
16053
16054 return res;
16055}
16056
16057static int
16058process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16059{
16060 Elf_External_Note * pnotes;
16061 Elf_External_Note * external;
16062 char * end;
16063 int res = 1;
16064
16065 if (length <= 0)
16066 return 0;
16067
16068 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16069 _("v850 notes"));
16070 if (pnotes == NULL)
16071 return 0;
16072
16073 external = pnotes;
16074 end = (char*) pnotes + length;
16075
16076 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16077 (unsigned long) offset, (unsigned long) length);
16078
16079 while ((char *) external + sizeof (Elf_External_Note) < end)
16080 {
16081 Elf_External_Note * next;
16082 Elf_Internal_Note inote;
16083
16084 inote.type = BYTE_GET (external->type);
16085 inote.namesz = BYTE_GET (external->namesz);
16086 inote.namedata = external->name;
16087 inote.descsz = BYTE_GET (external->descsz);
16088 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16089 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16090
16091 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16092 {
16093 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16094 inote.descdata = inote.namedata;
16095 inote.namesz = 0;
16096 }
16097
16098 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16099
16100 if ( ((char *) next > end)
16101 || ((char *) next < (char *) pnotes))
16102 {
16103 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16104 (unsigned long) ((char *) external - (char *) pnotes));
16105 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16106 inote.type, inote.namesz, inote.descsz);
16107 break;
16108 }
16109
16110 external = next;
16111
16112 /* Prevent out-of-bounds indexing. */
16113 if ( inote.namedata + inote.namesz > end
16114 || inote.namedata + inote.namesz < inote.namedata)
16115 {
16116 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16117 (unsigned long) ((char *) external - (char *) pnotes));
16118 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16119 inote.type, inote.namesz, inote.descsz);
16120 break;
16121 }
16122
16123 printf (" %s: ", get_v850_elf_note_type (inote.type));
16124
16125 if (! print_v850_note (& inote))
16126 {
16127 res = 0;
16128 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16129 inote.namesz, inote.descsz);
16130 }
16131 }
16132
16133 free (pnotes);
16134
16135 return res;
16136}
16137
16138static int
16139process_note_sections (FILE * file)
16140{
16141 Elf_Internal_Shdr * section;
16142 unsigned long i;
16143 int n = 0;
16144 int res = 1;
16145
16146 for (i = 0, section = section_headers;
16147 i < elf_header.e_shnum && section != NULL;
16148 i++, section++)
16149 {
16150 if (section->sh_type == SHT_NOTE)
16151 {
16152 res &= process_corefile_note_segment (file,
16153 (bfd_vma) section->sh_offset,
16154 (bfd_vma) section->sh_size);
16155 n++;
16156 }
16157
16158 if (( elf_header.e_machine == EM_V800
16159 || elf_header.e_machine == EM_V850
16160 || elf_header.e_machine == EM_CYGNUS_V850)
16161 && section->sh_type == SHT_RENESAS_INFO)
16162 {
16163 res &= process_v850_notes (file,
16164 (bfd_vma) section->sh_offset,
16165 (bfd_vma) section->sh_size);
16166 n++;
16167 }
16168 }
16169
16170 if (n == 0)
16171 /* Try processing NOTE segments instead. */
16172 return process_corefile_note_segments (file);
16173
16174 return res;
16175}
16176
16177static int
16178process_notes (FILE * file)
16179{
16180 /* If we have not been asked to display the notes then do nothing. */
16181 if (! do_notes)
16182 return 1;
16183
16184 if (elf_header.e_type != ET_CORE)
16185 return process_note_sections (file);
16186
16187 /* No program headers means no NOTE segment. */
16188 if (elf_header.e_phnum > 0)
16189 return process_corefile_note_segments (file);
16190
16191 printf (_("No note segments present in the core file.\n"));
16192 return 1;
16193}
16194
16195static int
16196process_arch_specific (FILE * file)
16197{
16198 if (! do_arch)
16199 return 1;
16200
16201 switch (elf_header.e_machine)
16202 {
16203 case EM_ARM:
16204 return process_arm_specific (file);
16205 case EM_MIPS:
16206 case EM_MIPS_RS3_LE:
16207 return process_mips_specific (file);
16208 break;
16209 case EM_NDS32:
16210 return process_nds32_specific (file);
16211 break;
16212 case EM_PPC:
16213 return process_power_specific (file);
16214 break;
16215 case EM_S390:
16216 case EM_S390_OLD:
16217 return process_s390_specific (file);
16218 break;
16219 case EM_SPARC:
16220 case EM_SPARC32PLUS:
16221 case EM_SPARCV9:
16222 return process_sparc_specific (file);
16223 break;
16224 case EM_TI_C6000:
16225 return process_tic6x_specific (file);
16226 break;
16227 case EM_MSP430:
16228 return process_msp430x_specific (file);
16229 default:
16230 break;
16231 }
16232 return 1;
16233}
16234
16235static int
16236get_file_header (FILE * file)
16237{
16238 /* Read in the identity array. */
16239 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
16240 return 0;
16241
16242 /* Determine how to read the rest of the header. */
16243 switch (elf_header.e_ident[EI_DATA])
16244 {
16245 default: /* fall through */
16246 case ELFDATANONE: /* fall through */
16247 case ELFDATA2LSB:
16248 byte_get = byte_get_little_endian;
16249 byte_put = byte_put_little_endian;
16250 break;
16251 case ELFDATA2MSB:
16252 byte_get = byte_get_big_endian;
16253 byte_put = byte_put_big_endian;
16254 break;
16255 }
16256
16257 /* For now we only support 32 bit and 64 bit ELF files. */
16258 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
16259
16260 /* Read in the rest of the header. */
16261 if (is_32bit_elf)
16262 {
16263 Elf32_External_Ehdr ehdr32;
16264
16265 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16266 return 0;
16267
16268 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16269 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16270 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16271 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16272 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16273 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16274 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16275 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16276 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16277 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16278 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16279 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16280 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16281 }
16282 else
16283 {
16284 Elf64_External_Ehdr ehdr64;
16285
16286 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16287 we will not be able to cope with the 64bit data found in
16288 64 ELF files. Detect this now and abort before we start
16289 overwriting things. */
16290 if (sizeof (bfd_vma) < 8)
16291 {
16292 error (_("This instance of readelf has been built without support for a\n\
1629364 bit data type and so it cannot read 64 bit ELF files.\n"));
16294 return 0;
16295 }
16296
16297 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16298 return 0;
16299
16300 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16301 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16302 elf_header.e_version = BYTE_GET (ehdr64.e_version);
16303 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16304 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16305 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
16306 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16307 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16308 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16309 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16310 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16311 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16312 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16313 }
16314
16315 if (elf_header.e_shoff)
16316 {
16317 /* There may be some extensions in the first section header. Don't
16318 bomb if we can't read it. */
16319 if (is_32bit_elf)
16320 get_32bit_section_headers (file, TRUE);
16321 else
16322 get_64bit_section_headers (file, TRUE);
16323 }
16324
16325 return 1;
16326}
16327
16328/* Process one ELF object file according to the command line options.
16329 This file may actually be stored in an archive. The file is
16330 positioned at the start of the ELF object. */
16331
16332static int
16333process_object (char * file_name, FILE * file)
16334{
16335 unsigned int i;
16336
16337 if (! get_file_header (file))
16338 {
16339 error (_("%s: Failed to read file header\n"), file_name);
16340 return 1;
16341 }
16342
16343 /* Initialise per file variables. */
16344 for (i = ARRAY_SIZE (version_info); i--;)
16345 version_info[i] = 0;
16346
16347 for (i = ARRAY_SIZE (dynamic_info); i--;)
16348 dynamic_info[i] = 0;
16349 dynamic_info_DT_GNU_HASH = 0;
16350
16351 /* Process the file. */
16352 if (show_name)
16353 printf (_("\nFile: %s\n"), file_name);
16354
16355 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16356 Note we do this even if cmdline_dump_sects is empty because we
16357 must make sure that the dump_sets array is zeroed out before each
16358 object file is processed. */
16359 if (num_dump_sects > num_cmdline_dump_sects)
16360 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
16361
16362 if (num_cmdline_dump_sects > 0)
16363 {
16364 if (num_dump_sects == 0)
16365 /* A sneaky way of allocating the dump_sects array. */
16366 request_dump_bynumber (num_cmdline_dump_sects, 0);
16367
16368 assert (num_dump_sects >= num_cmdline_dump_sects);
16369 memcpy (dump_sects, cmdline_dump_sects,
16370 num_cmdline_dump_sects * sizeof (* dump_sects));
16371 }
16372
16373 if (! process_file_header ())
16374 return 1;
16375
16376 if (! process_section_headers (file))
16377 {
16378 /* Without loaded section headers we cannot process lots of
16379 things. */
16380 do_unwind = do_version = do_dump = do_arch = 0;
16381
16382 if (! do_using_dynamic)
16383 do_syms = do_dyn_syms = do_reloc = 0;
16384 }
16385
16386 if (! process_section_groups (file))
16387 {
16388 /* Without loaded section groups we cannot process unwind. */
16389 do_unwind = 0;
16390 }
16391
16392 if (process_program_headers (file))
16393 process_dynamic_section (file);
16394
16395 process_relocs (file);
16396
16397 process_unwind (file);
16398
16399 process_symbol_table (file);
16400
16401 process_syminfo (file);
16402
16403 process_version_sections (file);
16404
16405 process_section_contents (file);
16406
16407 process_notes (file);
16408
16409 process_gnu_liblist (file);
16410
16411 process_arch_specific (file);
16412
16413 if (program_headers)
16414 {
16415 free (program_headers);
16416 program_headers = NULL;
16417 }
16418
16419 if (section_headers)
16420 {
16421 free (section_headers);
16422 section_headers = NULL;
16423 }
16424
16425 if (string_table)
16426 {
16427 free (string_table);
16428 string_table = NULL;
16429 string_table_length = 0;
16430 }
16431
16432 if (dynamic_strings)
16433 {
16434 free (dynamic_strings);
16435 dynamic_strings = NULL;
16436 dynamic_strings_length = 0;
16437 }
16438
16439 if (dynamic_symbols)
16440 {
16441 free (dynamic_symbols);
16442 dynamic_symbols = NULL;
16443 num_dynamic_syms = 0;
16444 }
16445
16446 if (dynamic_syminfo)
16447 {
16448 free (dynamic_syminfo);
16449 dynamic_syminfo = NULL;
16450 }
16451
16452 if (dynamic_section)
16453 {
16454 free (dynamic_section);
16455 dynamic_section = NULL;
16456 }
16457
16458 if (section_headers_groups)
16459 {
16460 free (section_headers_groups);
16461 section_headers_groups = NULL;
16462 }
16463
16464 if (section_groups)
16465 {
16466 struct group_list * g;
16467 struct group_list * next;
16468
16469 for (i = 0; i < group_count; i++)
16470 {
16471 for (g = section_groups [i].root; g != NULL; g = next)
16472 {
16473 next = g->next;
16474 free (g);
16475 }
16476 }
16477
16478 free (section_groups);
16479 section_groups = NULL;
16480 }
16481
16482 free_debug_memory ();
16483
16484 return 0;
16485}
16486
16487/* Process an ELF archive.
16488 On entry the file is positioned just after the ARMAG string. */
16489
16490static int
16491process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16492{
16493 struct archive_info arch;
16494 struct archive_info nested_arch;
16495 size_t got;
16496 int ret;
16497
16498 show_name = 1;
16499
16500 /* The ARCH structure is used to hold information about this archive. */
16501 arch.file_name = NULL;
16502 arch.file = NULL;
16503 arch.index_array = NULL;
16504 arch.sym_table = NULL;
16505 arch.longnames = NULL;
16506
16507 /* The NESTED_ARCH structure is used as a single-item cache of information
16508 about a nested archive (when members of a thin archive reside within
16509 another regular archive file). */
16510 nested_arch.file_name = NULL;
16511 nested_arch.file = NULL;
16512 nested_arch.index_array = NULL;
16513 nested_arch.sym_table = NULL;
16514 nested_arch.longnames = NULL;
16515
16516 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16517 {
16518 ret = 1;
16519 goto out;
16520 }
16521
16522 if (do_archive_index)
16523 {
16524 if (arch.sym_table == NULL)
16525 error (_("%s: unable to dump the index as none was found\n"), file_name);
16526 else
16527 {
16528 unsigned long i, l;
16529 unsigned long current_pos;
16530
16531 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16532 file_name, (unsigned long) arch.index_num, arch.sym_size);
16533 current_pos = ftell (file);
16534
16535 for (i = l = 0; i < arch.index_num; i++)
16536 {
16537 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16538 {
16539 char * member_name;
16540
16541 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16542
16543 if (member_name != NULL)
16544 {
16545 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16546
16547 if (qualified_name != NULL)
16548 {
16549 printf (_("Contents of binary %s at offset "), qualified_name);
16550 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16551 putchar ('\n');
16552 free (qualified_name);
16553 }
16554 }
16555 }
16556
16557 if (l >= arch.sym_size)
16558 {
16559 error (_("%s: end of the symbol table reached before the end of the index\n"),
16560 file_name);
16561 break;
16562 }
16563 /* PR 17531: file: 0b6630b2. */
16564 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16565 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
16566 }
16567
16568 if (arch.uses_64bit_indicies)
16569 l = (l + 7) & ~ 7;
16570 else
16571 l += l & 1;
16572
16573 if (l < arch.sym_size)
16574 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16575 file_name, arch.sym_size - l);
16576
16577 if (fseek (file, current_pos, SEEK_SET) != 0)
16578 {
16579 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
16580 ret = 1;
16581 goto out;
16582 }
16583 }
16584
16585 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16586 && !do_segments && !do_header && !do_dump && !do_version
16587 && !do_histogram && !do_debugging && !do_arch && !do_notes
16588 && !do_section_groups && !do_dyn_syms)
16589 {
16590 ret = 0; /* Archive index only. */
16591 goto out;
16592 }
16593 }
16594
16595 ret = 0;
16596
16597 while (1)
16598 {
16599 char * name;
16600 size_t namelen;
16601 char * qualified_name;
16602
16603 /* Read the next archive header. */
16604 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16605 {
16606 error (_("%s: failed to seek to next archive header\n"), file_name);
16607 return 1;
16608 }
16609 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16610 if (got != sizeof arch.arhdr)
16611 {
16612 if (got == 0)
16613 break;
16614 error (_("%s: failed to read archive header\n"), file_name);
16615 ret = 1;
16616 break;
16617 }
16618 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16619 {
16620 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16621 ret = 1;
16622 break;
16623 }
16624
16625 arch.next_arhdr_offset += sizeof arch.arhdr;
16626
16627 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16628 if (archive_file_size & 01)
16629 ++archive_file_size;
16630
16631 name = get_archive_member_name (&arch, &nested_arch);
16632 if (name == NULL)
16633 {
16634 error (_("%s: bad archive file name\n"), file_name);
16635 ret = 1;
16636 break;
16637 }
16638 namelen = strlen (name);
16639
16640 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16641 if (qualified_name == NULL)
16642 {
16643 error (_("%s: bad archive file name\n"), file_name);
16644 ret = 1;
16645 break;
16646 }
16647
16648 if (is_thin_archive && arch.nested_member_origin == 0)
16649 {
16650 /* This is a proxy for an external member of a thin archive. */
16651 FILE * member_file;
16652 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16653 if (member_file_name == NULL)
16654 {
16655 ret = 1;
16656 break;
16657 }
16658
16659 member_file = fopen (member_file_name, "rb");
16660 if (member_file == NULL)
16661 {
16662 error (_("Input file '%s' is not readable.\n"), member_file_name);
16663 free (member_file_name);
16664 ret = 1;
16665 break;
16666 }
16667
16668 archive_file_offset = arch.nested_member_origin;
16669
16670 ret |= process_object (qualified_name, member_file);
16671
16672 fclose (member_file);
16673 free (member_file_name);
16674 }
16675 else if (is_thin_archive)
16676 {
16677 /* PR 15140: Allow for corrupt thin archives. */
16678 if (nested_arch.file == NULL)
16679 {
16680 error (_("%s: contains corrupt thin archive: %s\n"),
16681 file_name, name);
16682 ret = 1;
16683 break;
16684 }
16685
16686 /* This is a proxy for a member of a nested archive. */
16687 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16688
16689 /* The nested archive file will have been opened and setup by
16690 get_archive_member_name. */
16691 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16692 {
16693 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16694 ret = 1;
16695 break;
16696 }
16697
16698 ret |= process_object (qualified_name, nested_arch.file);
16699 }
16700 else
16701 {
16702 archive_file_offset = arch.next_arhdr_offset;
16703 arch.next_arhdr_offset += archive_file_size;
16704
16705 ret |= process_object (qualified_name, file);
16706 }
16707
16708 if (dump_sects != NULL)
16709 {
16710 free (dump_sects);
16711 dump_sects = NULL;
16712 num_dump_sects = 0;
16713 }
16714
16715 free (qualified_name);
16716 }
16717
16718 out:
16719 if (nested_arch.file != NULL)
16720 fclose (nested_arch.file);
16721 release_archive (&nested_arch);
16722 release_archive (&arch);
16723
16724 return ret;
16725}
16726
16727static int
16728process_file (char * file_name)
16729{
16730 FILE * file;
16731 struct stat statbuf;
16732 char armag[SARMAG];
16733 int ret;
16734
16735 if (stat (file_name, &statbuf) < 0)
16736 {
16737 if (errno == ENOENT)
16738 error (_("'%s': No such file\n"), file_name);
16739 else
16740 error (_("Could not locate '%s'. System error message: %s\n"),
16741 file_name, strerror (errno));
16742 return 1;
16743 }
16744
16745 if (! S_ISREG (statbuf.st_mode))
16746 {
16747 error (_("'%s' is not an ordinary file\n"), file_name);
16748 return 1;
16749 }
16750
16751 file = fopen (file_name, "rb");
16752 if (file == NULL)
16753 {
16754 error (_("Input file '%s' is not readable.\n"), file_name);
16755 return 1;
16756 }
16757
16758 if (fread (armag, SARMAG, 1, file) != 1)
16759 {
16760 error (_("%s: Failed to read file's magic number\n"), file_name);
16761 fclose (file);
16762 return 1;
16763 }
16764
16765 current_file_size = (bfd_size_type) statbuf.st_size;
16766
16767 if (memcmp (armag, ARMAG, SARMAG) == 0)
16768 ret = process_archive (file_name, file, FALSE);
16769 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16770 ret = process_archive (file_name, file, TRUE);
16771 else
16772 {
16773 if (do_archive_index)
16774 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16775 file_name);
16776
16777 rewind (file);
16778 archive_file_size = archive_file_offset = 0;
16779 ret = process_object (file_name, file);
16780 }
16781
16782 fclose (file);
16783
16784 current_file_size = 0;
16785 return ret;
16786}
16787
16788#ifdef SUPPORT_DISASSEMBLY
16789/* Needed by the i386 disassembler. For extra credit, someone could
16790 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16791 symbols. */
16792
16793void
16794print_address (unsigned int addr, FILE * outfile)
16795{
16796 fprintf (outfile,"0x%8.8x", addr);
16797}
16798
16799/* Needed by the i386 disassembler. */
16800void
16801db_task_printsym (unsigned int addr)
16802{
16803 print_address (addr, stderr);
16804}
16805#endif
16806
16807int
16808main (int argc, char ** argv)
16809{
16810 int err;
16811
16812#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16813 setlocale (LC_MESSAGES, "");
16814#endif
16815#if defined (HAVE_SETLOCALE)
16816 setlocale (LC_CTYPE, "");
16817#endif
16818 bindtextdomain (PACKAGE, LOCALEDIR);
16819 textdomain (PACKAGE);
16820
16821 expandargv (&argc, &argv);
16822
16823 parse_args (argc, argv);
16824
16825 if (num_dump_sects > 0)
16826 {
16827 /* Make a copy of the dump_sects array. */
16828 cmdline_dump_sects = (dump_type *)
16829 malloc (num_dump_sects * sizeof (* dump_sects));
16830 if (cmdline_dump_sects == NULL)
16831 error (_("Out of memory allocating dump request table.\n"));
16832 else
16833 {
16834 memcpy (cmdline_dump_sects, dump_sects,
16835 num_dump_sects * sizeof (* dump_sects));
16836 num_cmdline_dump_sects = num_dump_sects;
16837 }
16838 }
16839
16840 if (optind < (argc - 1))
16841 show_name = 1;
16842 else if (optind >= argc)
16843 {
16844 warn (_("Nothing to do.\n"));
16845 usage (stderr);
16846 }
16847
16848 err = 0;
16849 while (optind < argc)
16850 err |= process_file (argv[optind++]);
16851
16852 if (dump_sects != NULL)
16853 free (dump_sects);
16854 if (cmdline_dump_sects != NULL)
16855 free (cmdline_dump_sects);
16856
16857 return err;
16858}
A mirror of the official binutils-gdb repository