projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
gdb/testsuite: Remove interactive prompt case from mi_gdb_test
[deliverable/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2019 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/csky.h"
102#include "elf/d10v.h"
103#include "elf/d30v.h"
104#include "elf/dlx.h"
105#include "elf/epiphany.h"
106#include "elf/fr30.h"
107#include "elf/frv.h"
108#include "elf/ft32.h"
109#include "elf/h8.h"
110#include "elf/hppa.h"
111#include "elf/i386.h"
112#include "elf/i370.h"
113#include "elf/i860.h"
114#include "elf/i960.h"
115#include "elf/ia64.h"
116#include "elf/ip2k.h"
117#include "elf/lm32.h"
118#include "elf/iq2000.h"
119#include "elf/m32c.h"
120#include "elf/m32r.h"
121#include "elf/m68k.h"
122#include "elf/m68hc11.h"
123#include "elf/s12z.h"
124#include "elf/mcore.h"
125#include "elf/mep.h"
126#include "elf/metag.h"
127#include "elf/microblaze.h"
128#include "elf/mips.h"
129#include "elf/mmix.h"
130#include "elf/mn10200.h"
131#include "elf/mn10300.h"
132#include "elf/moxie.h"
133#include "elf/mt.h"
134#include "elf/msp430.h"
135#include "elf/nds32.h"
136#include "elf/nfp.h"
137#include "elf/nios2.h"
138#include "elf/or1k.h"
139#include "elf/pj.h"
140#include "elf/ppc.h"
141#include "elf/ppc64.h"
142#include "elf/pru.h"
143#include "elf/riscv.h"
144#include "elf/rl78.h"
145#include "elf/rx.h"
146#include "elf/s390.h"
147#include "elf/score.h"
148#include "elf/sh.h"
149#include "elf/sparc.h"
150#include "elf/spu.h"
151#include "elf/tic6x.h"
152#include "elf/tilegx.h"
153#include "elf/tilepro.h"
154#include "elf/v850.h"
155#include "elf/vax.h"
156#include "elf/visium.h"
157#include "elf/wasm32.h"
158#include "elf/x86-64.h"
159#include "elf/xc16x.h"
160#include "elf/xgate.h"
161#include "elf/xstormy16.h"
162#include "elf/xtensa.h"
163
164#include "getopt.h"
165#include "libiberty.h"
166#include "safe-ctype.h"
167#include "filenames.h"
168
169#ifndef offsetof
170#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
171#endif
172
173typedef struct elf_section_list
174{
175 Elf_Internal_Shdr * hdr;
176 struct elf_section_list * next;
177} elf_section_list;
178
179/* Flag bits indicating particular types of dump. */
180#define HEX_DUMP (1 << 0) /* The -x command line switch. */
181#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
182#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
183#define STRING_DUMP (1 << 3) /* The -p command line switch. */
184#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
185
186typedef unsigned char dump_type;
187
188/* A linked list of the section names for which dumps were requested. */
189struct dump_list_entry
190{
191 char * name;
192 dump_type type;
193 struct dump_list_entry * next;
194};
195
196typedef struct filedata
197{
198 const char * file_name;
199 FILE * handle;
200 bfd_size_type file_size;
201 Elf_Internal_Ehdr file_header;
202 Elf_Internal_Shdr * section_headers;
203 Elf_Internal_Phdr * program_headers;
204 char * string_table;
205 unsigned long string_table_length;
206 /* A dynamic array of flags indicating for which sections a dump of
207 some kind has been requested. It is reset on a per-object file
208 basis and then initialised from the cmdline_dump_sects array,
209 the results of interpreting the -w switch, and the
210 dump_sects_byname list. */
211 dump_type * dump_sects;
212 unsigned int num_dump_sects;
213} Filedata;
214
215char * program_name = "readelf";
216
217static unsigned long archive_file_offset;
218static unsigned long archive_file_size;
219static unsigned long dynamic_addr;
220static bfd_size_type dynamic_size;
221static size_t dynamic_nent;
222static char * dynamic_strings;
223static unsigned long dynamic_strings_length;
224static unsigned long num_dynamic_syms;
225static Elf_Internal_Sym * dynamic_symbols;
226static Elf_Internal_Syminfo * dynamic_syminfo;
227static unsigned long dynamic_syminfo_offset;
228static unsigned int dynamic_syminfo_nent;
229static char program_interpreter[PATH_MAX];
230static bfd_vma dynamic_info[DT_ENCODING];
231static bfd_vma dynamic_info_DT_GNU_HASH;
232static bfd_vma version_info[16];
233static Elf_Internal_Dyn * dynamic_section;
234static elf_section_list * symtab_shndx_list;
235static bfd_boolean show_name = FALSE;
236static bfd_boolean do_dynamic = FALSE;
237static bfd_boolean do_syms = FALSE;
238static bfd_boolean do_dyn_syms = FALSE;
239static bfd_boolean do_reloc = FALSE;
240static bfd_boolean do_sections = FALSE;
241static bfd_boolean do_section_groups = FALSE;
242static bfd_boolean do_section_details = FALSE;
243static bfd_boolean do_segments = FALSE;
244static bfd_boolean do_unwind = FALSE;
245static bfd_boolean do_using_dynamic = FALSE;
246static bfd_boolean do_header = FALSE;
247static bfd_boolean do_dump = FALSE;
248static bfd_boolean do_version = FALSE;
249static bfd_boolean do_histogram = FALSE;
250static bfd_boolean do_debugging = FALSE;
251static bfd_boolean do_arch = FALSE;
252static bfd_boolean do_notes = FALSE;
253static bfd_boolean do_archive_index = FALSE;
254static bfd_boolean is_32bit_elf = FALSE;
255static bfd_boolean decompress_dumps = FALSE;
256
257struct group_list
258{
259 struct group_list * next;
260 unsigned int section_index;
261};
262
263struct group
264{
265 struct group_list * root;
266 unsigned int group_index;
267};
268
269static size_t group_count;
270static struct group * section_groups;
271static struct group ** section_headers_groups;
272
273/* A dynamic array of flags indicating for which sections a dump
274 has been requested via command line switches. */
275static Filedata cmdline;
276
277static struct dump_list_entry * dump_sects_byname;
278
279/* How to print a vma value. */
280typedef enum print_mode
281{
282 HEX,
283 DEC,
284 DEC_5,
285 UNSIGNED,
286 PREFIX_HEX,
287 FULL_HEX,
288 LONG_HEX
289}
290print_mode;
291
292/* Versioned symbol info. */
293enum versioned_symbol_info
294{
295 symbol_undefined,
296 symbol_hidden,
297 symbol_public
298};
299
300static const char * get_symbol_version_string
301 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
302 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
303
304#define UNKNOWN -1
305
306#define SECTION_NAME(X) \
307 ((X) == NULL ? _("<none>") \
308 : filedata->string_table == NULL ? _("<no-strings>") \
309 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
310 : filedata->string_table + (X)->sh_name))
311
312#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
313
314#define GET_ELF_SYMBOLS(file, section, sym_count) \
315 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
316 : get_64bit_elf_symbols (file, section, sym_count))
317
318#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
319/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
320 already been called and verified that the string exists. */
321#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
322
323#define REMOVE_ARCH_BITS(ADDR) \
324 do \
325 { \
326 if (filedata->file_header.e_machine == EM_ARM) \
327 (ADDR) &= ~1; \
328 } \
329 while (0)
330\f
331/* Print a BFD_VMA to an internal buffer, for use in error messages.
332 BFD_FMA_FMT can't be used in translated strings. */
333
334static const char *
335bfd_vmatoa (char *fmtch, bfd_vma value)
336{
337 /* bfd_vmatoa is used more then once in a printf call for output.
338 Cycle through an array of buffers. */
339 static int buf_pos = 0;
340 static struct bfd_vmatoa_buf
341 {
342 char place[64];
343 } buf[4];
344 char *ret;
345 char fmt[32];
346
347 ret = buf[buf_pos++].place;
348 buf_pos %= ARRAY_SIZE (buf);
349
350 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
351 snprintf (ret, sizeof (buf[0].place), fmt, value);
352 return ret;
353}
354
355/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
356 OFFSET + the offset of the current archive member, if we are examining an
357 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
358 allocate a buffer using malloc and fill that. In either case return the
359 pointer to the start of the retrieved data or NULL if something went wrong.
360 If something does go wrong and REASON is not NULL then emit an error
361 message using REASON as part of the context. */
362
363static void *
364get_data (void * var,
365 Filedata * filedata,
366 unsigned long offset,
367 bfd_size_type size,
368 bfd_size_type nmemb,
369 const char * reason)
370{
371 void * mvar;
372 bfd_size_type amt = size * nmemb;
373
374 if (size == 0 || nmemb == 0)
375 return NULL;
376
377 /* If the size_t type is smaller than the bfd_size_type, eg because
378 you are building a 32-bit tool on a 64-bit host, then make sure
379 that when the sizes are cast to (size_t) no information is lost. */
380 if (sizeof (size_t) < sizeof (bfd_size_type)
381 && ( (bfd_size_type) ((size_t) size) != size
382 || (bfd_size_type) ((size_t) nmemb) != nmemb))
383 {
384 if (reason)
385 error (_("Size truncation prevents reading %s"
386 " elements of size %s for %s\n"),
387 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
388 return NULL;
389 }
390
391 /* Check for size overflow. */
392 if (amt < nmemb)
393 {
394 if (reason)
395 error (_("Size overflow prevents reading %s"
396 " elements of size %s for %s\n"),
397 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
398 return NULL;
399 }
400
401 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
402 attempting to allocate memory when the read is bound to fail. */
403 if (amt > filedata->file_size
404 || offset + archive_file_offset + amt > filedata->file_size)
405 {
406 if (reason)
407 error (_("Reading %s bytes extends past end of file for %s\n"),
408 bfd_vmatoa ("u", amt), reason);
409 return NULL;
410 }
411
412 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
413 {
414 if (reason)
415 error (_("Unable to seek to 0x%lx for %s\n"),
416 archive_file_offset + offset, reason);
417 return NULL;
418 }
419
420 mvar = var;
421 if (mvar == NULL)
422 {
423 /* Check for overflow. */
424 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
425 /* + 1 so that we can '\0' terminate invalid string table sections. */
426 mvar = malloc ((size_t) amt + 1);
427
428 if (mvar == NULL)
429 {
430 if (reason)
431 error (_("Out of memory allocating %s bytes for %s\n"),
432 bfd_vmatoa ("u", amt), reason);
433 return NULL;
434 }
435
436 ((char *) mvar)[amt] = '\0';
437 }
438
439 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
440 {
441 if (reason)
442 error (_("Unable to read in %s bytes of %s\n"),
443 bfd_vmatoa ("u", amt), reason);
444 if (mvar != var)
445 free (mvar);
446 return NULL;
447 }
448
449 return mvar;
450}
451
452/* Print a VMA value in the MODE specified.
453 Returns the number of characters displayed. */
454
455static unsigned int
456print_vma (bfd_vma vma, print_mode mode)
457{
458 unsigned int nc = 0;
459
460 switch (mode)
461 {
462 case FULL_HEX:
463 nc = printf ("0x");
464 /* Fall through. */
465 case LONG_HEX:
466#ifdef BFD64
467 if (is_32bit_elf)
468 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
469#endif
470 printf_vma (vma);
471 return nc + 16;
472
473 case DEC_5:
474 if (vma <= 99999)
475 return printf ("%5" BFD_VMA_FMT "d", vma);
476 /* Fall through. */
477 case PREFIX_HEX:
478 nc = printf ("0x");
479 /* Fall through. */
480 case HEX:
481 return nc + printf ("%" BFD_VMA_FMT "x", vma);
482
483 case DEC:
484 return printf ("%" BFD_VMA_FMT "d", vma);
485
486 case UNSIGNED:
487 return printf ("%" BFD_VMA_FMT "u", vma);
488
489 default:
490 /* FIXME: Report unrecognised mode ? */
491 return 0;
492 }
493}
494
495/* Display a symbol on stdout. Handles the display of control characters and
496 multibye characters (assuming the host environment supports them).
497
498 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
499
500 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
501 padding as necessary.
502
503 Returns the number of emitted characters. */
504
505static unsigned int
506print_symbol (signed int width, const char *symbol)
507{
508 bfd_boolean extra_padding = FALSE;
509 signed int num_printed = 0;
510#ifdef HAVE_MBSTATE_T
511 mbstate_t state;
512#endif
513 unsigned int width_remaining;
514
515 if (width < 0)
516 {
517 /* Keep the width positive. This helps the code below. */
518 width = - width;
519 extra_padding = TRUE;
520 }
521 else if (width == 0)
522 return 0;
523
524 if (do_wide)
525 /* Set the remaining width to a very large value.
526 This simplifies the code below. */
527 width_remaining = INT_MAX;
528 else
529 width_remaining = width;
530
531#ifdef HAVE_MBSTATE_T
532 /* Initialise the multibyte conversion state. */
533 memset (& state, 0, sizeof (state));
534#endif
535
536 while (width_remaining)
537 {
538 size_t n;
539 const char c = *symbol++;
540
541 if (c == 0)
542 break;
543
544 /* Do not print control characters directly as they can affect terminal
545 settings. Such characters usually appear in the names generated
546 by the assembler for local labels. */
547 if (ISCNTRL (c))
548 {
549 if (width_remaining < 2)
550 break;
551
552 printf ("^%c", c + 0x40);
553 width_remaining -= 2;
554 num_printed += 2;
555 }
556 else if (ISPRINT (c))
557 {
558 putchar (c);
559 width_remaining --;
560 num_printed ++;
561 }
562 else
563 {
564#ifdef HAVE_MBSTATE_T
565 wchar_t w;
566#endif
567 /* Let printf do the hard work of displaying multibyte characters. */
568 printf ("%.1s", symbol - 1);
569 width_remaining --;
570 num_printed ++;
571
572#ifdef HAVE_MBSTATE_T
573 /* Try to find out how many bytes made up the character that was
574 just printed. Advance the symbol pointer past the bytes that
575 were displayed. */
576 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
577#else
578 n = 1;
579#endif
580 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
581 symbol += (n - 1);
582 }
583 }
584
585 if (extra_padding && num_printed < width)
586 {
587 /* Fill in the remaining spaces. */
588 printf ("%-*s", width - num_printed, " ");
589 num_printed = width;
590 }
591
592 return num_printed;
593}
594
595/* Returns a pointer to a static buffer containing a printable version of
596 the given section's name. Like print_symbol, except that it does not try
597 to print multibyte characters, it just interprets them as hex values. */
598
599static const char *
600printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
601{
602#define MAX_PRINT_SEC_NAME_LEN 128
603 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
604 const char * name = SECTION_NAME (sec);
605 char * buf = sec_name_buf;
606 char c;
607 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
608
609 while ((c = * name ++) != 0)
610 {
611 if (ISCNTRL (c))
612 {
613 if (remaining < 2)
614 break;
615
616 * buf ++ = '^';
617 * buf ++ = c + 0x40;
618 remaining -= 2;
619 }
620 else if (ISPRINT (c))
621 {
622 * buf ++ = c;
623 remaining -= 1;
624 }
625 else
626 {
627 static char hex[17] = "0123456789ABCDEF";
628
629 if (remaining < 4)
630 break;
631 * buf ++ = '<';
632 * buf ++ = hex[(c & 0xf0) >> 4];
633 * buf ++ = hex[c & 0x0f];
634 * buf ++ = '>';
635 remaining -= 4;
636 }
637
638 if (remaining == 0)
639 break;
640 }
641
642 * buf = 0;
643 return sec_name_buf;
644}
645
646static const char *
647printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
648{
649 if (ndx >= filedata->file_header.e_shnum)
650 return _("<corrupt>");
651
652 return printable_section_name (filedata, filedata->section_headers + ndx);
653}
654
655/* Return a pointer to section NAME, or NULL if no such section exists. */
656
657static Elf_Internal_Shdr *
658find_section (Filedata * filedata, const char * name)
659{
660 unsigned int i;
661
662 if (filedata->section_headers == NULL)
663 return NULL;
664
665 for (i = 0; i < filedata->file_header.e_shnum; i++)
666 if (streq (SECTION_NAME (filedata->section_headers + i), name))
667 return filedata->section_headers + i;
668
669 return NULL;
670}
671
672/* Return a pointer to a section containing ADDR, or NULL if no such
673 section exists. */
674
675static Elf_Internal_Shdr *
676find_section_by_address (Filedata * filedata, bfd_vma addr)
677{
678 unsigned int i;
679
680 if (filedata->section_headers == NULL)
681 return NULL;
682
683 for (i = 0; i < filedata->file_header.e_shnum; i++)
684 {
685 Elf_Internal_Shdr *sec = filedata->section_headers + i;
686
687 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
688 return sec;
689 }
690
691 return NULL;
692}
693
694static Elf_Internal_Shdr *
695find_section_by_type (Filedata * filedata, unsigned int type)
696{
697 unsigned int i;
698
699 if (filedata->section_headers == NULL)
700 return NULL;
701
702 for (i = 0; i < filedata->file_header.e_shnum; i++)
703 {
704 Elf_Internal_Shdr *sec = filedata->section_headers + i;
705
706 if (sec->sh_type == type)
707 return sec;
708 }
709
710 return NULL;
711}
712
713/* Return a pointer to section NAME, or NULL if no such section exists,
714 restricted to the list of sections given in SET. */
715
716static Elf_Internal_Shdr *
717find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
718{
719 unsigned int i;
720
721 if (filedata->section_headers == NULL)
722 return NULL;
723
724 if (set != NULL)
725 {
726 while ((i = *set++) > 0)
727 {
728 /* See PR 21156 for a reproducer. */
729 if (i >= filedata->file_header.e_shnum)
730 continue; /* FIXME: Should we issue an error message ? */
731
732 if (streq (SECTION_NAME (filedata->section_headers + i), name))
733 return filedata->section_headers + i;
734 }
735 }
736
737 return find_section (filedata, name);
738}
739
740/* Read an unsigned LEB128 encoded value from DATA.
741 Set *LENGTH_RETURN to the number of bytes read. */
742
743static inline unsigned long
744read_uleb128 (unsigned char * data,
745 unsigned int * length_return,
746 const unsigned char * const end)
747{
748 return read_leb128 (data, length_return, FALSE, end);
749}
750
751/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
752 This OS has so many departures from the ELF standard that we test it at
753 many places. */
754
755static inline bfd_boolean
756is_ia64_vms (Filedata * filedata)
757{
758 return filedata->file_header.e_machine == EM_IA_64
759 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
760}
761
762/* Guess the relocation size commonly used by the specific machines. */
763
764static bfd_boolean
765guess_is_rela (unsigned int e_machine)
766{
767 switch (e_machine)
768 {
769 /* Targets that use REL relocations. */
770 case EM_386:
771 case EM_IAMCU:
772 case EM_960:
773 case EM_ARM:
774 case EM_D10V:
775 case EM_CYGNUS_D10V:
776 case EM_DLX:
777 case EM_MIPS:
778 case EM_MIPS_RS3_LE:
779 case EM_CYGNUS_M32R:
780 case EM_SCORE:
781 case EM_XGATE:
782 case EM_NFP:
783 return FALSE;
784
785 /* Targets that use RELA relocations. */
786 case EM_68K:
787 case EM_860:
788 case EM_AARCH64:
789 case EM_ADAPTEVA_EPIPHANY:
790 case EM_ALPHA:
791 case EM_ALTERA_NIOS2:
792 case EM_ARC:
793 case EM_ARC_COMPACT:
794 case EM_ARC_COMPACT2:
795 case EM_AVR:
796 case EM_AVR_OLD:
797 case EM_BLACKFIN:
798 case EM_CR16:
799 case EM_CRIS:
800 case EM_CRX:
801 case EM_CSKY:
802 case EM_D30V:
803 case EM_CYGNUS_D30V:
804 case EM_FR30:
805 case EM_FT32:
806 case EM_CYGNUS_FR30:
807 case EM_CYGNUS_FRV:
808 case EM_H8S:
809 case EM_H8_300:
810 case EM_H8_300H:
811 case EM_IA_64:
812 case EM_IP2K:
813 case EM_IP2K_OLD:
814 case EM_IQ2000:
815 case EM_LATTICEMICO32:
816 case EM_M32C_OLD:
817 case EM_M32C:
818 case EM_M32R:
819 case EM_MCORE:
820 case EM_CYGNUS_MEP:
821 case EM_METAG:
822 case EM_MMIX:
823 case EM_MN10200:
824 case EM_CYGNUS_MN10200:
825 case EM_MN10300:
826 case EM_CYGNUS_MN10300:
827 case EM_MOXIE:
828 case EM_MSP430:
829 case EM_MSP430_OLD:
830 case EM_MT:
831 case EM_NDS32:
832 case EM_NIOS32:
833 case EM_OR1K:
834 case EM_PPC64:
835 case EM_PPC:
836 case EM_TI_PRU:
837 case EM_RISCV:
838 case EM_RL78:
839 case EM_RX:
840 case EM_S390:
841 case EM_S390_OLD:
842 case EM_SH:
843 case EM_SPARC:
844 case EM_SPARC32PLUS:
845 case EM_SPARCV9:
846 case EM_SPU:
847 case EM_TI_C6000:
848 case EM_TILEGX:
849 case EM_TILEPRO:
850 case EM_V800:
851 case EM_V850:
852 case EM_CYGNUS_V850:
853 case EM_VAX:
854 case EM_VISIUM:
855 case EM_X86_64:
856 case EM_L1OM:
857 case EM_K1OM:
858 case EM_XSTORMY16:
859 case EM_XTENSA:
860 case EM_XTENSA_OLD:
861 case EM_MICROBLAZE:
862 case EM_MICROBLAZE_OLD:
863 case EM_WEBASSEMBLY:
864 return TRUE;
865
866 case EM_68HC05:
867 case EM_68HC08:
868 case EM_68HC11:
869 case EM_68HC16:
870 case EM_FX66:
871 case EM_ME16:
872 case EM_MMA:
873 case EM_NCPU:
874 case EM_NDR1:
875 case EM_PCP:
876 case EM_ST100:
877 case EM_ST19:
878 case EM_ST7:
879 case EM_ST9PLUS:
880 case EM_STARCORE:
881 case EM_SVX:
882 case EM_TINYJ:
883 default:
884 warn (_("Don't know about relocations on this machine architecture\n"));
885 return FALSE;
886 }
887}
888
889/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
890 Returns TRUE upon success, FALSE otherwise. If successful then a
891 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
892 and the number of relocs loaded is placed in *NRELASP. It is the caller's
893 responsibility to free the allocated buffer. */
894
895static bfd_boolean
896slurp_rela_relocs (Filedata * filedata,
897 unsigned long rel_offset,
898 unsigned long rel_size,
899 Elf_Internal_Rela ** relasp,
900 unsigned long * nrelasp)
901{
902 Elf_Internal_Rela * relas;
903 size_t nrelas;
904 unsigned int i;
905
906 if (is_32bit_elf)
907 {
908 Elf32_External_Rela * erelas;
909
910 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
911 rel_size, _("32-bit relocation data"));
912 if (!erelas)
913 return FALSE;
914
915 nrelas = rel_size / sizeof (Elf32_External_Rela);
916
917 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
918 sizeof (Elf_Internal_Rela));
919
920 if (relas == NULL)
921 {
922 free (erelas);
923 error (_("out of memory parsing relocs\n"));
924 return FALSE;
925 }
926
927 for (i = 0; i < nrelas; i++)
928 {
929 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
930 relas[i].r_info = BYTE_GET (erelas[i].r_info);
931 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
932 }
933
934 free (erelas);
935 }
936 else
937 {
938 Elf64_External_Rela * erelas;
939
940 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
941 rel_size, _("64-bit relocation data"));
942 if (!erelas)
943 return FALSE;
944
945 nrelas = rel_size / sizeof (Elf64_External_Rela);
946
947 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
948 sizeof (Elf_Internal_Rela));
949
950 if (relas == NULL)
951 {
952 free (erelas);
953 error (_("out of memory parsing relocs\n"));
954 return FALSE;
955 }
956
957 for (i = 0; i < nrelas; i++)
958 {
959 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
960 relas[i].r_info = BYTE_GET (erelas[i].r_info);
961 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
962
963 /* The #ifdef BFD64 below is to prevent a compile time
964 warning. We know that if we do not have a 64 bit data
965 type that we will never execute this code anyway. */
966#ifdef BFD64
967 if (filedata->file_header.e_machine == EM_MIPS
968 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
969 {
970 /* In little-endian objects, r_info isn't really a
971 64-bit little-endian value: it has a 32-bit
972 little-endian symbol index followed by four
973 individual byte fields. Reorder INFO
974 accordingly. */
975 bfd_vma inf = relas[i].r_info;
976 inf = (((inf & 0xffffffff) << 32)
977 | ((inf >> 56) & 0xff)
978 | ((inf >> 40) & 0xff00)
979 | ((inf >> 24) & 0xff0000)
980 | ((inf >> 8) & 0xff000000));
981 relas[i].r_info = inf;
982 }
983#endif /* BFD64 */
984 }
985
986 free (erelas);
987 }
988
989 *relasp = relas;
990 *nrelasp = nrelas;
991 return TRUE;
992}
993
994/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
995 Returns TRUE upon success, FALSE otherwise. If successful then a
996 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
997 and the number of relocs loaded is placed in *NRELSP. It is the caller's
998 responsibility to free the allocated buffer. */
999
1000static bfd_boolean
1001slurp_rel_relocs (Filedata * filedata,
1002 unsigned long rel_offset,
1003 unsigned long rel_size,
1004 Elf_Internal_Rela ** relsp,
1005 unsigned long * nrelsp)
1006{
1007 Elf_Internal_Rela * rels;
1008 size_t nrels;
1009 unsigned int i;
1010
1011 if (is_32bit_elf)
1012 {
1013 Elf32_External_Rel * erels;
1014
1015 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016 rel_size, _("32-bit relocation data"));
1017 if (!erels)
1018 return FALSE;
1019
1020 nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024 if (rels == NULL)
1025 {
1026 free (erels);
1027 error (_("out of memory parsing relocs\n"));
1028 return FALSE;
1029 }
1030
1031 for (i = 0; i < nrels; i++)
1032 {
1033 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034 rels[i].r_info = BYTE_GET (erels[i].r_info);
1035 rels[i].r_addend = 0;
1036 }
1037
1038 free (erels);
1039 }
1040 else
1041 {
1042 Elf64_External_Rel * erels;
1043
1044 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045 rel_size, _("64-bit relocation data"));
1046 if (!erels)
1047 return FALSE;
1048
1049 nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053 if (rels == NULL)
1054 {
1055 free (erels);
1056 error (_("out of memory parsing relocs\n"));
1057 return FALSE;
1058 }
1059
1060 for (i = 0; i < nrels; i++)
1061 {
1062 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063 rels[i].r_info = BYTE_GET (erels[i].r_info);
1064 rels[i].r_addend = 0;
1065
1066 /* The #ifdef BFD64 below is to prevent a compile time
1067 warning. We know that if we do not have a 64 bit data
1068 type that we will never execute this code anyway. */
1069#ifdef BFD64
1070 if (filedata->file_header.e_machine == EM_MIPS
1071 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072 {
1073 /* In little-endian objects, r_info isn't really a
1074 64-bit little-endian value: it has a 32-bit
1075 little-endian symbol index followed by four
1076 individual byte fields. Reorder INFO
1077 accordingly. */
1078 bfd_vma inf = rels[i].r_info;
1079 inf = (((inf & 0xffffffff) << 32)
1080 | ((inf >> 56) & 0xff)
1081 | ((inf >> 40) & 0xff00)
1082 | ((inf >> 24) & 0xff0000)
1083 | ((inf >> 8) & 0xff000000));
1084 rels[i].r_info = inf;
1085 }
1086#endif /* BFD64 */
1087 }
1088
1089 free (erels);
1090 }
1091
1092 *relsp = rels;
1093 *nrelsp = nrels;
1094 return TRUE;
1095}
1096
1097/* Returns the reloc type extracted from the reloc info field. */
1098
1099static unsigned int
1100get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101{
1102 if (is_32bit_elf)
1103 return ELF32_R_TYPE (reloc_info);
1104
1105 switch (filedata->file_header.e_machine)
1106 {
1107 case EM_MIPS:
1108 /* Note: We assume that reloc_info has already been adjusted for us. */
1109 return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111 case EM_SPARCV9:
1112 return ELF64_R_TYPE_ID (reloc_info);
1113
1114 default:
1115 return ELF64_R_TYPE (reloc_info);
1116 }
1117}
1118
1119/* Return the symbol index extracted from the reloc info field. */
1120
1121static bfd_vma
1122get_reloc_symindex (bfd_vma reloc_info)
1123{
1124 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125}
1126
1127static inline bfd_boolean
1128uses_msp430x_relocs (Filedata * filedata)
1129{
1130 return
1131 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1132 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1133 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134 /* TI compiler uses ELFOSABI_NONE. */
1135 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136}
1137
1138/* Display the contents of the relocation data found at the specified
1139 offset. */
1140
1141static bfd_boolean
1142dump_relocations (Filedata * filedata,
1143 unsigned long rel_offset,
1144 unsigned long rel_size,
1145 Elf_Internal_Sym * symtab,
1146 unsigned long nsyms,
1147 char * strtab,
1148 unsigned long strtablen,
1149 int is_rela,
1150 bfd_boolean is_dynsym)
1151{
1152 unsigned long i;
1153 Elf_Internal_Rela * rels;
1154 bfd_boolean res = TRUE;
1155
1156 if (is_rela == UNKNOWN)
1157 is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159 if (is_rela)
1160 {
1161 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162 return FALSE;
1163 }
1164 else
1165 {
1166 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167 return FALSE;
1168 }
1169
1170 if (is_32bit_elf)
1171 {
1172 if (is_rela)
1173 {
1174 if (do_wide)
1175 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1176 else
1177 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1178 }
1179 else
1180 {
1181 if (do_wide)
1182 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1183 else
1184 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1185 }
1186 }
1187 else
1188 {
1189 if (is_rela)
1190 {
1191 if (do_wide)
1192 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1193 else
1194 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1195 }
1196 else
1197 {
1198 if (do_wide)
1199 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1200 else
1201 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1202 }
1203 }
1204
1205 for (i = 0; i < rel_size; i++)
1206 {
1207 const char * rtype;
1208 bfd_vma offset;
1209 bfd_vma inf;
1210 bfd_vma symtab_index;
1211 bfd_vma type;
1212
1213 offset = rels[i].r_offset;
1214 inf = rels[i].r_info;
1215
1216 type = get_reloc_type (filedata, inf);
1217 symtab_index = get_reloc_symindex (inf);
1218
1219 if (is_32bit_elf)
1220 {
1221 printf ("%8.8lx %8.8lx ",
1222 (unsigned long) offset & 0xffffffff,
1223 (unsigned long) inf & 0xffffffff);
1224 }
1225 else
1226 {
1227#if BFD_HOST_64BIT_LONG
1228 printf (do_wide
1229 ? "%16.16lx %16.16lx "
1230 : "%12.12lx %12.12lx ",
1231 offset, inf);
1232#elif BFD_HOST_64BIT_LONG_LONG
1233#ifndef __MSVCRT__
1234 printf (do_wide
1235 ? "%16.16llx %16.16llx "
1236 : "%12.12llx %12.12llx ",
1237 offset, inf);
1238#else
1239 printf (do_wide
1240 ? "%16.16I64x %16.16I64x "
1241 : "%12.12I64x %12.12I64x ",
1242 offset, inf);
1243#endif
1244#else
1245 printf (do_wide
1246 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1247 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1248 _bfd_int64_high (offset),
1249 _bfd_int64_low (offset),
1250 _bfd_int64_high (inf),
1251 _bfd_int64_low (inf));
1252#endif
1253 }
1254
1255 switch (filedata->file_header.e_machine)
1256 {
1257 default:
1258 rtype = NULL;
1259 break;
1260
1261 case EM_AARCH64:
1262 rtype = elf_aarch64_reloc_type (type);
1263 break;
1264
1265 case EM_M32R:
1266 case EM_CYGNUS_M32R:
1267 rtype = elf_m32r_reloc_type (type);
1268 break;
1269
1270 case EM_386:
1271 case EM_IAMCU:
1272 rtype = elf_i386_reloc_type (type);
1273 break;
1274
1275 case EM_68HC11:
1276 case EM_68HC12:
1277 rtype = elf_m68hc11_reloc_type (type);
1278 break;
1279
1280 case EM_S12Z:
1281 rtype = elf_s12z_reloc_type (type);
1282 break;
1283
1284 case EM_68K:
1285 rtype = elf_m68k_reloc_type (type);
1286 break;
1287
1288 case EM_960:
1289 rtype = elf_i960_reloc_type (type);
1290 break;
1291
1292 case EM_AVR:
1293 case EM_AVR_OLD:
1294 rtype = elf_avr_reloc_type (type);
1295 break;
1296
1297 case EM_OLD_SPARCV9:
1298 case EM_SPARC32PLUS:
1299 case EM_SPARCV9:
1300 case EM_SPARC:
1301 rtype = elf_sparc_reloc_type (type);
1302 break;
1303
1304 case EM_SPU:
1305 rtype = elf_spu_reloc_type (type);
1306 break;
1307
1308 case EM_V800:
1309 rtype = v800_reloc_type (type);
1310 break;
1311 case EM_V850:
1312 case EM_CYGNUS_V850:
1313 rtype = v850_reloc_type (type);
1314 break;
1315
1316 case EM_D10V:
1317 case EM_CYGNUS_D10V:
1318 rtype = elf_d10v_reloc_type (type);
1319 break;
1320
1321 case EM_D30V:
1322 case EM_CYGNUS_D30V:
1323 rtype = elf_d30v_reloc_type (type);
1324 break;
1325
1326 case EM_DLX:
1327 rtype = elf_dlx_reloc_type (type);
1328 break;
1329
1330 case EM_SH:
1331 rtype = elf_sh_reloc_type (type);
1332 break;
1333
1334 case EM_MN10300:
1335 case EM_CYGNUS_MN10300:
1336 rtype = elf_mn10300_reloc_type (type);
1337 break;
1338
1339 case EM_MN10200:
1340 case EM_CYGNUS_MN10200:
1341 rtype = elf_mn10200_reloc_type (type);
1342 break;
1343
1344 case EM_FR30:
1345 case EM_CYGNUS_FR30:
1346 rtype = elf_fr30_reloc_type (type);
1347 break;
1348
1349 case EM_CYGNUS_FRV:
1350 rtype = elf_frv_reloc_type (type);
1351 break;
1352
1353 case EM_CSKY:
1354 rtype = elf_csky_reloc_type (type);
1355 break;
1356
1357 case EM_FT32:
1358 rtype = elf_ft32_reloc_type (type);
1359 break;
1360
1361 case EM_MCORE:
1362 rtype = elf_mcore_reloc_type (type);
1363 break;
1364
1365 case EM_MMIX:
1366 rtype = elf_mmix_reloc_type (type);
1367 break;
1368
1369 case EM_MOXIE:
1370 rtype = elf_moxie_reloc_type (type);
1371 break;
1372
1373 case EM_MSP430:
1374 if (uses_msp430x_relocs (filedata))
1375 {
1376 rtype = elf_msp430x_reloc_type (type);
1377 break;
1378 }
1379 /* Fall through. */
1380 case EM_MSP430_OLD:
1381 rtype = elf_msp430_reloc_type (type);
1382 break;
1383
1384 case EM_NDS32:
1385 rtype = elf_nds32_reloc_type (type);
1386 break;
1387
1388 case EM_PPC:
1389 rtype = elf_ppc_reloc_type (type);
1390 break;
1391
1392 case EM_PPC64:
1393 rtype = elf_ppc64_reloc_type (type);
1394 break;
1395
1396 case EM_MIPS:
1397 case EM_MIPS_RS3_LE:
1398 rtype = elf_mips_reloc_type (type);
1399 break;
1400
1401 case EM_RISCV:
1402 rtype = elf_riscv_reloc_type (type);
1403 break;
1404
1405 case EM_ALPHA:
1406 rtype = elf_alpha_reloc_type (type);
1407 break;
1408
1409 case EM_ARM:
1410 rtype = elf_arm_reloc_type (type);
1411 break;
1412
1413 case EM_ARC:
1414 case EM_ARC_COMPACT:
1415 case EM_ARC_COMPACT2:
1416 rtype = elf_arc_reloc_type (type);
1417 break;
1418
1419 case EM_PARISC:
1420 rtype = elf_hppa_reloc_type (type);
1421 break;
1422
1423 case EM_H8_300:
1424 case EM_H8_300H:
1425 case EM_H8S:
1426 rtype = elf_h8_reloc_type (type);
1427 break;
1428
1429 case EM_OR1K:
1430 rtype = elf_or1k_reloc_type (type);
1431 break;
1432
1433 case EM_PJ:
1434 case EM_PJ_OLD:
1435 rtype = elf_pj_reloc_type (type);
1436 break;
1437 case EM_IA_64:
1438 rtype = elf_ia64_reloc_type (type);
1439 break;
1440
1441 case EM_CRIS:
1442 rtype = elf_cris_reloc_type (type);
1443 break;
1444
1445 case EM_860:
1446 rtype = elf_i860_reloc_type (type);
1447 break;
1448
1449 case EM_X86_64:
1450 case EM_L1OM:
1451 case EM_K1OM:
1452 rtype = elf_x86_64_reloc_type (type);
1453 break;
1454
1455 case EM_S370:
1456 rtype = i370_reloc_type (type);
1457 break;
1458
1459 case EM_S390_OLD:
1460 case EM_S390:
1461 rtype = elf_s390_reloc_type (type);
1462 break;
1463
1464 case EM_SCORE:
1465 rtype = elf_score_reloc_type (type);
1466 break;
1467
1468 case EM_XSTORMY16:
1469 rtype = elf_xstormy16_reloc_type (type);
1470 break;
1471
1472 case EM_CRX:
1473 rtype = elf_crx_reloc_type (type);
1474 break;
1475
1476 case EM_VAX:
1477 rtype = elf_vax_reloc_type (type);
1478 break;
1479
1480 case EM_VISIUM:
1481 rtype = elf_visium_reloc_type (type);
1482 break;
1483
1484 case EM_ADAPTEVA_EPIPHANY:
1485 rtype = elf_epiphany_reloc_type (type);
1486 break;
1487
1488 case EM_IP2K:
1489 case EM_IP2K_OLD:
1490 rtype = elf_ip2k_reloc_type (type);
1491 break;
1492
1493 case EM_IQ2000:
1494 rtype = elf_iq2000_reloc_type (type);
1495 break;
1496
1497 case EM_XTENSA_OLD:
1498 case EM_XTENSA:
1499 rtype = elf_xtensa_reloc_type (type);
1500 break;
1501
1502 case EM_LATTICEMICO32:
1503 rtype = elf_lm32_reloc_type (type);
1504 break;
1505
1506 case EM_M32C_OLD:
1507 case EM_M32C:
1508 rtype = elf_m32c_reloc_type (type);
1509 break;
1510
1511 case EM_MT:
1512 rtype = elf_mt_reloc_type (type);
1513 break;
1514
1515 case EM_BLACKFIN:
1516 rtype = elf_bfin_reloc_type (type);
1517 break;
1518
1519 case EM_CYGNUS_MEP:
1520 rtype = elf_mep_reloc_type (type);
1521 break;
1522
1523 case EM_CR16:
1524 rtype = elf_cr16_reloc_type (type);
1525 break;
1526
1527 case EM_MICROBLAZE:
1528 case EM_MICROBLAZE_OLD:
1529 rtype = elf_microblaze_reloc_type (type);
1530 break;
1531
1532 case EM_RL78:
1533 rtype = elf_rl78_reloc_type (type);
1534 break;
1535
1536 case EM_RX:
1537 rtype = elf_rx_reloc_type (type);
1538 break;
1539
1540 case EM_METAG:
1541 rtype = elf_metag_reloc_type (type);
1542 break;
1543
1544 case EM_XC16X:
1545 case EM_C166:
1546 rtype = elf_xc16x_reloc_type (type);
1547 break;
1548
1549 case EM_TI_C6000:
1550 rtype = elf_tic6x_reloc_type (type);
1551 break;
1552
1553 case EM_TILEGX:
1554 rtype = elf_tilegx_reloc_type (type);
1555 break;
1556
1557 case EM_TILEPRO:
1558 rtype = elf_tilepro_reloc_type (type);
1559 break;
1560
1561 case EM_WEBASSEMBLY:
1562 rtype = elf_wasm32_reloc_type (type);
1563 break;
1564
1565 case EM_XGATE:
1566 rtype = elf_xgate_reloc_type (type);
1567 break;
1568
1569 case EM_ALTERA_NIOS2:
1570 rtype = elf_nios2_reloc_type (type);
1571 break;
1572
1573 case EM_TI_PRU:
1574 rtype = elf_pru_reloc_type (type);
1575 break;
1576
1577 case EM_NFP:
1578 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579 rtype = elf_nfp3200_reloc_type (type);
1580 else
1581 rtype = elf_nfp_reloc_type (type);
1582 break;
1583 }
1584
1585 if (rtype == NULL)
1586 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587 else
1588 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590 if (filedata->file_header.e_machine == EM_ALPHA
1591 && rtype != NULL
1592 && streq (rtype, "R_ALPHA_LITUSE")
1593 && is_rela)
1594 {
1595 switch (rels[i].r_addend)
1596 {
1597 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1598 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1599 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1601 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1602 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604 default: rtype = NULL;
1605 }
1606
1607 if (rtype)
1608 printf (" (%s)", rtype);
1609 else
1610 {
1611 putchar (' ');
1612 printf (_("<unknown addend: %lx>"),
1613 (unsigned long) rels[i].r_addend);
1614 res = FALSE;
1615 }
1616 }
1617 else if (symtab_index)
1618 {
1619 if (symtab == NULL || symtab_index >= nsyms)
1620 {
1621 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622 res = FALSE;
1623 }
1624 else
1625 {
1626 Elf_Internal_Sym * psym;
1627 const char * version_string;
1628 enum versioned_symbol_info sym_info;
1629 unsigned short vna_other;
1630
1631 psym = symtab + symtab_index;
1632
1633 version_string
1634 = get_symbol_version_string (filedata, is_dynsym,
1635 strtab, strtablen,
1636 symtab_index,
1637 psym,
1638 &sym_info,
1639 &vna_other);
1640
1641 printf (" ");
1642
1643 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644 {
1645 const char * name;
1646 unsigned int len;
1647 unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649 /* Relocations against GNU_IFUNC symbols do not use the value
1650 of the symbol as the address to relocate against. Instead
1651 they invoke the function named by the symbol and use its
1652 result as the address for relocation.
1653
1654 To indicate this to the user, do not display the value of
1655 the symbol in the "Symbols's Value" field. Instead show
1656 its name followed by () as a hint that the symbol is
1657 invoked. */
1658
1659 if (strtab == NULL
1660 || psym->st_name == 0
1661 || psym->st_name >= strtablen)
1662 name = "??";
1663 else
1664 name = strtab + psym->st_name;
1665
1666 len = print_symbol (width, name);
1667 if (version_string)
1668 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669 version_string);
1670 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671 }
1672 else
1673 {
1674 print_vma (psym->st_value, LONG_HEX);
1675
1676 printf (is_32bit_elf ? " " : " ");
1677 }
1678
1679 if (psym->st_name == 0)
1680 {
1681 const char * sec_name = "<null>";
1682 char name_buf[40];
1683
1684 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685 {
1686 if (psym->st_shndx < filedata->file_header.e_shnum)
1687 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688 else if (psym->st_shndx == SHN_ABS)
1689 sec_name = "ABS";
1690 else if (psym->st_shndx == SHN_COMMON)
1691 sec_name = "COMMON";
1692 else if ((filedata->file_header.e_machine == EM_MIPS
1693 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694 || (filedata->file_header.e_machine == EM_TI_C6000
1695 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696 sec_name = "SCOMMON";
1697 else if (filedata->file_header.e_machine == EM_MIPS
1698 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699 sec_name = "SUNDEF";
1700 else if ((filedata->file_header.e_machine == EM_X86_64
1701 || filedata->file_header.e_machine == EM_L1OM
1702 || filedata->file_header.e_machine == EM_K1OM)
1703 && psym->st_shndx == SHN_X86_64_LCOMMON)
1704 sec_name = "LARGE_COMMON";
1705 else if (filedata->file_header.e_machine == EM_IA_64
1706 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708 sec_name = "ANSI_COM";
1709 else if (is_ia64_vms (filedata)
1710 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711 sec_name = "VMS_SYMVEC";
1712 else
1713 {
1714 sprintf (name_buf, "<section 0x%x>",
1715 (unsigned int) psym->st_shndx);
1716 sec_name = name_buf;
1717 }
1718 }
1719 print_symbol (22, sec_name);
1720 }
1721 else if (strtab == NULL)
1722 printf (_("<string table index: %3ld>"), psym->st_name);
1723 else if (psym->st_name >= strtablen)
1724 {
1725 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726 res = FALSE;
1727 }
1728 else
1729 {
1730 print_symbol (22, strtab + psym->st_name);
1731 if (version_string)
1732 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733 version_string);
1734 }
1735
1736 if (is_rela)
1737 {
1738 bfd_vma off = rels[i].r_addend;
1739
1740 if ((bfd_signed_vma) off < 0)
1741 printf (" - %" BFD_VMA_FMT "x", - off);
1742 else
1743 printf (" + %" BFD_VMA_FMT "x", off);
1744 }
1745 }
1746 }
1747 else if (is_rela)
1748 {
1749 bfd_vma off = rels[i].r_addend;
1750
1751 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752 if ((bfd_signed_vma) off < 0)
1753 printf ("-%" BFD_VMA_FMT "x", - off);
1754 else
1755 printf ("%" BFD_VMA_FMT "x", off);
1756 }
1757
1758 if (filedata->file_header.e_machine == EM_SPARCV9
1759 && rtype != NULL
1760 && streq (rtype, "R_SPARC_OLO10"))
1761 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763 putchar ('\n');
1764
1765#ifdef BFD64
1766 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767 {
1768 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770 const char * rtype2 = elf_mips_reloc_type (type2);
1771 const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773 printf (" Type2: ");
1774
1775 if (rtype2 == NULL)
1776 printf (_("unrecognized: %-7lx"),
1777 (unsigned long) type2 & 0xffffffff);
1778 else
1779 printf ("%-17.17s", rtype2);
1780
1781 printf ("\n Type3: ");
1782
1783 if (rtype3 == NULL)
1784 printf (_("unrecognized: %-7lx"),
1785 (unsigned long) type3 & 0xffffffff);
1786 else
1787 printf ("%-17.17s", rtype3);
1788
1789 putchar ('\n');
1790 }
1791#endif /* BFD64 */
1792 }
1793
1794 free (rels);
1795
1796 return res;
1797}
1798
1799static const char *
1800get_mips_dynamic_type (unsigned long type)
1801{
1802 switch (type)
1803 {
1804 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810 case DT_MIPS_MSYM: return "MIPS_MSYM";
1811 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850 default:
1851 return NULL;
1852 }
1853}
1854
1855static const char *
1856get_sparc64_dynamic_type (unsigned long type)
1857{
1858 switch (type)
1859 {
1860 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861 default:
1862 return NULL;
1863 }
1864}
1865
1866static const char *
1867get_ppc_dynamic_type (unsigned long type)
1868{
1869 switch (type)
1870 {
1871 case DT_PPC_GOT: return "PPC_GOT";
1872 case DT_PPC_OPT: return "PPC_OPT";
1873 default:
1874 return NULL;
1875 }
1876}
1877
1878static const char *
1879get_ppc64_dynamic_type (unsigned long type)
1880{
1881 switch (type)
1882 {
1883 case DT_PPC64_GLINK: return "PPC64_GLINK";
1884 case DT_PPC64_OPD: return "PPC64_OPD";
1885 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1886 case DT_PPC64_OPT: return "PPC64_OPT";
1887 default:
1888 return NULL;
1889 }
1890}
1891
1892static const char *
1893get_parisc_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1898 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1899 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1900 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1901 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1902 case DT_HP_PREINIT: return "HP_PREINIT";
1903 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1904 case DT_HP_NEEDED: return "HP_NEEDED";
1905 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1906 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1907 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1908 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1909 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1910 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1911 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1912 case DT_HP_FILTERED: return "HP_FILTERED";
1913 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1914 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1916 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1917 case DT_PLT: return "PLT";
1918 case DT_PLT_SIZE: return "PLT_SIZE";
1919 case DT_DLT: return "DLT";
1920 case DT_DLT_SIZE: return "DLT_SIZE";
1921 default:
1922 return NULL;
1923 }
1924}
1925
1926static const char *
1927get_ia64_dynamic_type (unsigned long type)
1928{
1929 switch (type)
1930 {
1931 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1932 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1933 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1934 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1935 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1937 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1938 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1939 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1940 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1941 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1942 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1943 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1944 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1945 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1946 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1947 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1948 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1949 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1950 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1951 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1952 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1953 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1954 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1955 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1956 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1957 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1958 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1959 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1960 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1961 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1962 default:
1963 return NULL;
1964 }
1965}
1966
1967static const char *
1968get_solaris_section_type (unsigned long type)
1969{
1970 switch (type)
1971 {
1972 case 0x6fffffee: return "SUNW_ancillary";
1973 case 0x6fffffef: return "SUNW_capchain";
1974 case 0x6ffffff0: return "SUNW_capinfo";
1975 case 0x6ffffff1: return "SUNW_symsort";
1976 case 0x6ffffff2: return "SUNW_tlssort";
1977 case 0x6ffffff3: return "SUNW_LDYNSYM";
1978 case 0x6ffffff4: return "SUNW_dof";
1979 case 0x6ffffff5: return "SUNW_cap";
1980 case 0x6ffffff6: return "SUNW_SIGNATURE";
1981 case 0x6ffffff7: return "SUNW_ANNOTATE";
1982 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983 case 0x6ffffff9: return "SUNW_DEBUG";
1984 case 0x6ffffffa: return "SUNW_move";
1985 case 0x6ffffffb: return "SUNW_COMDAT";
1986 case 0x6ffffffc: return "SUNW_syminfo";
1987 case 0x6ffffffd: return "SUNW_verdef";
1988 case 0x6ffffffe: return "SUNW_verneed";
1989 case 0x6fffffff: return "SUNW_versym";
1990 case 0x70000000: return "SPARC_GOTDATA";
1991 default: return NULL;
1992 }
1993}
1994
1995static const char *
1996get_alpha_dynamic_type (unsigned long type)
1997{
1998 switch (type)
1999 {
2000 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001 default: return NULL;
2002 }
2003}
2004
2005static const char *
2006get_score_dynamic_type (unsigned long type)
2007{
2008 switch (type)
2009 {
2010 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2012 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2013 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2014 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2015 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2016 default: return NULL;
2017 }
2018}
2019
2020static const char *
2021get_tic6x_dynamic_type (unsigned long type)
2022{
2023 switch (type)
2024 {
2025 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2028 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2029 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2030 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2031 default: return NULL;
2032 }
2033}
2034
2035static const char *
2036get_nios2_dynamic_type (unsigned long type)
2037{
2038 switch (type)
2039 {
2040 case DT_NIOS2_GP: return "NIOS2_GP";
2041 default: return NULL;
2042 }
2043}
2044
2045static const char *
2046get_solaris_dynamic_type (unsigned long type)
2047{
2048 switch (type)
2049 {
2050 case 0x6000000d: return "SUNW_AUXILIARY";
2051 case 0x6000000e: return "SUNW_RTLDINF";
2052 case 0x6000000f: return "SUNW_FILTER";
2053 case 0x60000010: return "SUNW_CAP";
2054 case 0x60000011: return "SUNW_SYMTAB";
2055 case 0x60000012: return "SUNW_SYMSZ";
2056 case 0x60000013: return "SUNW_SORTENT";
2057 case 0x60000014: return "SUNW_SYMSORT";
2058 case 0x60000015: return "SUNW_SYMSORTSZ";
2059 case 0x60000016: return "SUNW_TLSSORT";
2060 case 0x60000017: return "SUNW_TLSSORTSZ";
2061 case 0x60000018: return "SUNW_CAPINFO";
2062 case 0x60000019: return "SUNW_STRPAD";
2063 case 0x6000001a: return "SUNW_CAPCHAIN";
2064 case 0x6000001b: return "SUNW_LDMACH";
2065 case 0x6000001d: return "SUNW_CAPCHAINENT";
2066 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067 case 0x60000021: return "SUNW_PARENT";
2068 case 0x60000023: return "SUNW_ASLR";
2069 case 0x60000025: return "SUNW_RELAX";
2070 case 0x60000029: return "SUNW_NXHEAP";
2071 case 0x6000002b: return "SUNW_NXSTACK";
2072
2073 case 0x70000001: return "SPARC_REGISTER";
2074 case 0x7ffffffd: return "AUXILIARY";
2075 case 0x7ffffffe: return "USED";
2076 case 0x7fffffff: return "FILTER";
2077
2078 default: return NULL;
2079 }
2080}
2081
2082static const char *
2083get_dynamic_type (Filedata * filedata, unsigned long type)
2084{
2085 static char buff[64];
2086
2087 switch (type)
2088 {
2089 case DT_NULL: return "NULL";
2090 case DT_NEEDED: return "NEEDED";
2091 case DT_PLTRELSZ: return "PLTRELSZ";
2092 case DT_PLTGOT: return "PLTGOT";
2093 case DT_HASH: return "HASH";
2094 case DT_STRTAB: return "STRTAB";
2095 case DT_SYMTAB: return "SYMTAB";
2096 case DT_RELA: return "RELA";
2097 case DT_RELASZ: return "RELASZ";
2098 case DT_RELAENT: return "RELAENT";
2099 case DT_STRSZ: return "STRSZ";
2100 case DT_SYMENT: return "SYMENT";
2101 case DT_INIT: return "INIT";
2102 case DT_FINI: return "FINI";
2103 case DT_SONAME: return "SONAME";
2104 case DT_RPATH: return "RPATH";
2105 case DT_SYMBOLIC: return "SYMBOLIC";
2106 case DT_REL: return "REL";
2107 case DT_RELSZ: return "RELSZ";
2108 case DT_RELENT: return "RELENT";
2109 case DT_PLTREL: return "PLTREL";
2110 case DT_DEBUG: return "DEBUG";
2111 case DT_TEXTREL: return "TEXTREL";
2112 case DT_JMPREL: return "JMPREL";
2113 case DT_BIND_NOW: return "BIND_NOW";
2114 case DT_INIT_ARRAY: return "INIT_ARRAY";
2115 case DT_FINI_ARRAY: return "FINI_ARRAY";
2116 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118 case DT_RUNPATH: return "RUNPATH";
2119 case DT_FLAGS: return "FLAGS";
2120
2121 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125 case DT_CHECKSUM: return "CHECKSUM";
2126 case DT_PLTPADSZ: return "PLTPADSZ";
2127 case DT_MOVEENT: return "MOVEENT";
2128 case DT_MOVESZ: return "MOVESZ";
2129 case DT_FEATURE: return "FEATURE";
2130 case DT_POSFLAG_1: return "POSFLAG_1";
2131 case DT_SYMINSZ: return "SYMINSZ";
2132 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2133
2134 case DT_ADDRRNGLO: return "ADDRRNGLO";
2135 case DT_CONFIG: return "CONFIG";
2136 case DT_DEPAUDIT: return "DEPAUDIT";
2137 case DT_AUDIT: return "AUDIT";
2138 case DT_PLTPAD: return "PLTPAD";
2139 case DT_MOVETAB: return "MOVETAB";
2140 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142 case DT_VERSYM: return "VERSYM";
2143
2144 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146 case DT_RELACOUNT: return "RELACOUNT";
2147 case DT_RELCOUNT: return "RELCOUNT";
2148 case DT_FLAGS_1: return "FLAGS_1";
2149 case DT_VERDEF: return "VERDEF";
2150 case DT_VERDEFNUM: return "VERDEFNUM";
2151 case DT_VERNEED: return "VERNEED";
2152 case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154 case DT_AUXILIARY: return "AUXILIARY";
2155 case DT_USED: return "USED";
2156 case DT_FILTER: return "FILTER";
2157
2158 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163 case DT_GNU_HASH: return "GNU_HASH";
2164
2165 default:
2166 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167 {
2168 const char * result;
2169
2170 switch (filedata->file_header.e_machine)
2171 {
2172 case EM_MIPS:
2173 case EM_MIPS_RS3_LE:
2174 result = get_mips_dynamic_type (type);
2175 break;
2176 case EM_SPARCV9:
2177 result = get_sparc64_dynamic_type (type);
2178 break;
2179 case EM_PPC:
2180 result = get_ppc_dynamic_type (type);
2181 break;
2182 case EM_PPC64:
2183 result = get_ppc64_dynamic_type (type);
2184 break;
2185 case EM_IA_64:
2186 result = get_ia64_dynamic_type (type);
2187 break;
2188 case EM_ALPHA:
2189 result = get_alpha_dynamic_type (type);
2190 break;
2191 case EM_SCORE:
2192 result = get_score_dynamic_type (type);
2193 break;
2194 case EM_TI_C6000:
2195 result = get_tic6x_dynamic_type (type);
2196 break;
2197 case EM_ALTERA_NIOS2:
2198 result = get_nios2_dynamic_type (type);
2199 break;
2200 default:
2201 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202 result = get_solaris_dynamic_type (type);
2203 else
2204 result = NULL;
2205 break;
2206 }
2207
2208 if (result != NULL)
2209 return result;
2210
2211 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212 }
2213 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214 || (filedata->file_header.e_machine == EM_PARISC
2215 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216 {
2217 const char * result;
2218
2219 switch (filedata->file_header.e_machine)
2220 {
2221 case EM_PARISC:
2222 result = get_parisc_dynamic_type (type);
2223 break;
2224 case EM_IA_64:
2225 result = get_ia64_dynamic_type (type);
2226 break;
2227 default:
2228 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229 result = get_solaris_dynamic_type (type);
2230 else
2231 result = NULL;
2232 break;
2233 }
2234
2235 if (result != NULL)
2236 return result;
2237
2238 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239 type);
2240 }
2241 else
2242 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244 return buff;
2245 }
2246}
2247
2248static char *
2249get_file_type (unsigned e_type)
2250{
2251 static char buff[32];
2252
2253 switch (e_type)
2254 {
2255 case ET_NONE: return _("NONE (None)");
2256 case ET_REL: return _("REL (Relocatable file)");
2257 case ET_EXEC: return _("EXEC (Executable file)");
2258 case ET_DYN: return _("DYN (Shared object file)");
2259 case ET_CORE: return _("CORE (Core file)");
2260
2261 default:
2262 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266 else
2267 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268 return buff;
2269 }
2270}
2271
2272static char *
2273get_machine_name (unsigned e_machine)
2274{
2275 static char buff[64]; /* XXX */
2276
2277 switch (e_machine)
2278 {
2279 /* Please keep this switch table sorted by increasing EM_ value. */
2280 /* 0 */
2281 case EM_NONE: return _("None");
2282 case EM_M32: return "WE32100";
2283 case EM_SPARC: return "Sparc";
2284 case EM_386: return "Intel 80386";
2285 case EM_68K: return "MC68000";
2286 case EM_88K: return "MC88000";
2287 case EM_IAMCU: return "Intel MCU";
2288 case EM_860: return "Intel 80860";
2289 case EM_MIPS: return "MIPS R3000";
2290 case EM_S370: return "IBM System/370";
2291 /* 10 */
2292 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2293 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2294 case EM_PARISC: return "HPPA";
2295 case EM_VPP550: return "Fujitsu VPP500";
2296 case EM_SPARC32PLUS: return "Sparc v8+" ;
2297 case EM_960: return "Intel 80960";
2298 case EM_PPC: return "PowerPC";
2299 /* 20 */
2300 case EM_PPC64: return "PowerPC64";
2301 case EM_S390_OLD:
2302 case EM_S390: return "IBM S/390";
2303 case EM_SPU: return "SPU";
2304 /* 30 */
2305 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2306 case EM_FR20: return "Fujitsu FR20";
2307 case EM_RH32: return "TRW RH32";
2308 case EM_MCORE: return "MCORE";
2309 /* 40 */
2310 case EM_ARM: return "ARM";
2311 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2312 case EM_SH: return "Renesas / SuperH SH";
2313 case EM_SPARCV9: return "Sparc v9";
2314 case EM_TRICORE: return "Siemens Tricore";
2315 case EM_ARC: return "ARC";
2316 case EM_H8_300: return "Renesas H8/300";
2317 case EM_H8_300H: return "Renesas H8/300H";
2318 case EM_H8S: return "Renesas H8S";
2319 case EM_H8_500: return "Renesas H8/500";
2320 /* 50 */
2321 case EM_IA_64: return "Intel IA-64";
2322 case EM_MIPS_X: return "Stanford MIPS-X";
2323 case EM_COLDFIRE: return "Motorola Coldfire";
2324 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2325 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2326 case EM_PCP: return "Siemens PCP";
2327 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2328 case EM_NDR1: return "Denso NDR1 microprocesspr";
2329 case EM_STARCORE: return "Motorola Star*Core processor";
2330 case EM_ME16: return "Toyota ME16 processor";
2331 /* 60 */
2332 case EM_ST100: return "STMicroelectronics ST100 processor";
2333 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2334 case EM_X86_64: return "Advanced Micro Devices X86-64";
2335 case EM_PDSP: return "Sony DSP processor";
2336 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2337 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2338 case EM_FX66: return "Siemens FX66 microcontroller";
2339 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2341 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2342 /* 70 */
2343 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2344 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2345 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2346 case EM_SVX: return "Silicon Graphics SVx";
2347 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2348 case EM_VAX: return "Digital VAX";
2349 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2350 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2351 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2352 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2353 /* 80 */
2354 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2355 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2356 case EM_PRISM: return "Vitesse Prism";
2357 case EM_AVR_OLD:
2358 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2359 case EM_CYGNUS_FR30:
2360 case EM_FR30: return "Fujitsu FR30";
2361 case EM_CYGNUS_D10V:
2362 case EM_D10V: return "d10v";
2363 case EM_CYGNUS_D30V:
2364 case EM_D30V: return "d30v";
2365 case EM_CYGNUS_V850:
2366 case EM_V850: return "Renesas V850";
2367 case EM_CYGNUS_M32R:
2368 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2369 case EM_CYGNUS_MN10300:
2370 case EM_MN10300: return "mn10300";
2371 /* 90 */
2372 case EM_CYGNUS_MN10200:
2373 case EM_MN10200: return "mn10200";
2374 case EM_PJ: return "picoJava";
2375 case EM_OR1K: return "OpenRISC 1000";
2376 case EM_ARC_COMPACT: return "ARCompact";
2377 case EM_XTENSA_OLD:
2378 case EM_XTENSA: return "Tensilica Xtensa Processor";
2379 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2380 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2381 case EM_NS32K: return "National Semiconductor 32000 series";
2382 case EM_TPC: return "Tenor Network TPC processor";
2383 case EM_SNP1K: return "Trebia SNP 1000 processor";
2384 /* 100 */
2385 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2386 case EM_IP2K_OLD:
2387 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2388 case EM_MAX: return "MAX Processor";
2389 case EM_CR: return "National Semiconductor CompactRISC";
2390 case EM_F2MC16: return "Fujitsu F2MC16";
2391 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2392 case EM_BLACKFIN: return "Analog Devices Blackfin";
2393 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2394 case EM_SEP: return "Sharp embedded microprocessor";
2395 case EM_ARCA: return "Arca RISC microprocessor";
2396 /* 110 */
2397 case EM_UNICORE: return "Unicore";
2398 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2399 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2400 case EM_ALTERA_NIOS2: return "Altera Nios II";
2401 case EM_CRX: return "National Semiconductor CRX microprocessor";
2402 case EM_XGATE: return "Motorola XGATE embedded processor";
2403 case EM_C166:
2404 case EM_XC16X: return "Infineon Technologies xc16x";
2405 case EM_M16C: return "Renesas M16C series microprocessors";
2406 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2407 case EM_CE: return "Freescale Communication Engine RISC core";
2408 /* 120 */
2409 case EM_M32C: return "Renesas M32c";
2410 /* 130 */
2411 case EM_TSK3000: return "Altium TSK3000 core";
2412 case EM_RS08: return "Freescale RS08 embedded processor";
2413 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2414 case EM_SCORE: return "SUNPLUS S+Core";
2415 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2416 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2417 case EM_LATTICEMICO32: return "Lattice Mico32";
2418 case EM_SE_C17: return "Seiko Epson C17 family";
2419 /* 140 */
2420 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2421 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2422 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2423 case EM_TI_PRU: return "TI PRU I/O processor";
2424 /* 160 */
2425 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2427 case EM_R32C: return "Renesas R32C series microprocessors";
2428 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2429 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2430 case EM_8051: return "Intel 8051 and variants";
2431 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2432 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2433 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2434 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435 /* 170 */
2436 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2437 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2438 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2439 case EM_RX: return "Renesas RX";
2440 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2441 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2442 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2443 case EM_CR16:
2444 case EM_MICROBLAZE:
2445 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2446 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2447 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2448 /* 180 */
2449 case EM_L1OM: return "Intel L1OM";
2450 case EM_K1OM: return "Intel K1OM";
2451 case EM_INTEL182: return "Intel (reserved)";
2452 case EM_AARCH64: return "AArch64";
2453 case EM_ARM184: return "ARM (reserved)";
2454 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2455 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2456 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2457 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2458 /* 190 */
2459 case EM_CUDA: return "NVIDIA CUDA architecture";
2460 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2461 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2462 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2463 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2464 case EM_ARC_COMPACT2: return "ARCv2";
2465 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2466 case EM_RL78: return "Renesas RL78";
2467 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2468 case EM_78K0R: return "Renesas 78K0R";
2469 /* 200 */
2470 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2471 case EM_BA1: return "Beyond BA1 CPU architecture";
2472 case EM_BA2: return "Beyond BA2 CPU architecture";
2473 case EM_XCORE: return "XMOS xCORE processor family";
2474 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2475 /* 210 */
2476 case EM_KM32: return "KM211 KM32 32-bit processor";
2477 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2478 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2479 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2480 case EM_KVARC: return "KM211 KVARC processor";
2481 case EM_CDP: return "Paneve CDP architecture family";
2482 case EM_COGE: return "Cognitive Smart Memory Processor";
2483 case EM_COOL: return "Bluechip Systems CoolEngine";
2484 case EM_NORC: return "Nanoradio Optimized RISC";
2485 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2486 /* 220 */
2487 case EM_Z80: return "Zilog Z80";
2488 case EM_VISIUM: return "CDS VISIUMcore processor";
2489 case EM_FT32: return "FTDI Chip FT32";
2490 case EM_MOXIE: return "Moxie";
2491 case EM_AMDGPU: return "AMD GPU";
2492 case EM_RISCV: return "RISC-V";
2493 case EM_LANAI: return "Lanai 32-bit processor";
2494 case EM_BPF: return "Linux BPF";
2495 case EM_NFP: return "Netronome Flow Processor";
2496
2497 /* Large numbers... */
2498 case EM_MT: return "Morpho Techologies MT processor";
2499 case EM_ALPHA: return "Alpha";
2500 case EM_WEBASSEMBLY: return "Web Assembly";
2501 case EM_DLX: return "OpenDLX";
2502 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2503 case EM_IQ2000: return "Vitesse IQ2000";
2504 case EM_M32C_OLD:
2505 case EM_NIOS32: return "Altera Nios";
2506 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2507 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2508 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2509 case EM_S12Z: return "Freescale S12Z";
2510 case EM_CSKY: return "C-SKY";
2511
2512 default:
2513 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514 return buff;
2515 }
2516}
2517
2518static void
2519decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520{
2521 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2522 other compilers don't a specific architecture type in the e_flags, and
2523 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525 architectures.
2526
2527 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528 but also sets a specific architecture type in the e_flags field.
2529
2530 However, when decoding the flags we don't worry if we see an
2531 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532 ARCEM architecture type. */
2533
2534 switch (e_flags & EF_ARC_MACH_MSK)
2535 {
2536 /* We only expect these to occur for EM_ARC_COMPACT2. */
2537 case EF_ARC_CPU_ARCV2EM:
2538 strcat (buf, ", ARC EM");
2539 break;
2540 case EF_ARC_CPU_ARCV2HS:
2541 strcat (buf, ", ARC HS");
2542 break;
2543
2544 /* We only expect these to occur for EM_ARC_COMPACT. */
2545 case E_ARC_MACH_ARC600:
2546 strcat (buf, ", ARC600");
2547 break;
2548 case E_ARC_MACH_ARC601:
2549 strcat (buf, ", ARC601");
2550 break;
2551 case E_ARC_MACH_ARC700:
2552 strcat (buf, ", ARC700");
2553 break;
2554
2555 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556 new ELF with new architecture being read by an old version of
2557 readelf, or (c) An ELF built with non-GNU compiler that does not
2558 set the architecture in the e_flags. */
2559 default:
2560 if (e_machine == EM_ARC_COMPACT)
2561 strcat (buf, ", Unknown ARCompact");
2562 else
2563 strcat (buf, ", Unknown ARC");
2564 break;
2565 }
2566
2567 switch (e_flags & EF_ARC_OSABI_MSK)
2568 {
2569 case E_ARC_OSABI_ORIG:
2570 strcat (buf, ", (ABI:legacy)");
2571 break;
2572 case E_ARC_OSABI_V2:
2573 strcat (buf, ", (ABI:v2)");
2574 break;
2575 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2576 case E_ARC_OSABI_V3:
2577 strcat (buf, ", v3 no-legacy-syscalls ABI");
2578 break;
2579 case E_ARC_OSABI_V4:
2580 strcat (buf, ", v4 ABI");
2581 break;
2582 default:
2583 strcat (buf, ", unrecognised ARC OSABI flag");
2584 break;
2585 }
2586}
2587
2588static void
2589decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590{
2591 unsigned eabi;
2592 bfd_boolean unknown = FALSE;
2593
2594 eabi = EF_ARM_EABI_VERSION (e_flags);
2595 e_flags &= ~ EF_ARM_EABIMASK;
2596
2597 /* Handle "generic" ARM flags. */
2598 if (e_flags & EF_ARM_RELEXEC)
2599 {
2600 strcat (buf, ", relocatable executable");
2601 e_flags &= ~ EF_ARM_RELEXEC;
2602 }
2603
2604 if (e_flags & EF_ARM_PIC)
2605 {
2606 strcat (buf, ", position independent");
2607 e_flags &= ~ EF_ARM_PIC;
2608 }
2609
2610 /* Now handle EABI specific flags. */
2611 switch (eabi)
2612 {
2613 default:
2614 strcat (buf, ", <unrecognized EABI>");
2615 if (e_flags)
2616 unknown = TRUE;
2617 break;
2618
2619 case EF_ARM_EABI_VER1:
2620 strcat (buf, ", Version1 EABI");
2621 while (e_flags)
2622 {
2623 unsigned flag;
2624
2625 /* Process flags one bit at a time. */
2626 flag = e_flags & - e_flags;
2627 e_flags &= ~ flag;
2628
2629 switch (flag)
2630 {
2631 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2632 strcat (buf, ", sorted symbol tables");
2633 break;
2634
2635 default:
2636 unknown = TRUE;
2637 break;
2638 }
2639 }
2640 break;
2641
2642 case EF_ARM_EABI_VER2:
2643 strcat (buf, ", Version2 EABI");
2644 while (e_flags)
2645 {
2646 unsigned flag;
2647
2648 /* Process flags one bit at a time. */
2649 flag = e_flags & - e_flags;
2650 e_flags &= ~ flag;
2651
2652 switch (flag)
2653 {
2654 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2655 strcat (buf, ", sorted symbol tables");
2656 break;
2657
2658 case EF_ARM_DYNSYMSUSESEGIDX:
2659 strcat (buf, ", dynamic symbols use segment index");
2660 break;
2661
2662 case EF_ARM_MAPSYMSFIRST:
2663 strcat (buf, ", mapping symbols precede others");
2664 break;
2665
2666 default:
2667 unknown = TRUE;
2668 break;
2669 }
2670 }
2671 break;
2672
2673 case EF_ARM_EABI_VER3:
2674 strcat (buf, ", Version3 EABI");
2675 break;
2676
2677 case EF_ARM_EABI_VER4:
2678 strcat (buf, ", Version4 EABI");
2679 while (e_flags)
2680 {
2681 unsigned flag;
2682
2683 /* Process flags one bit at a time. */
2684 flag = e_flags & - e_flags;
2685 e_flags &= ~ flag;
2686
2687 switch (flag)
2688 {
2689 case EF_ARM_BE8:
2690 strcat (buf, ", BE8");
2691 break;
2692
2693 case EF_ARM_LE8:
2694 strcat (buf, ", LE8");
2695 break;
2696
2697 default:
2698 unknown = TRUE;
2699 break;
2700 }
2701 }
2702 break;
2703
2704 case EF_ARM_EABI_VER5:
2705 strcat (buf, ", Version5 EABI");
2706 while (e_flags)
2707 {
2708 unsigned flag;
2709
2710 /* Process flags one bit at a time. */
2711 flag = e_flags & - e_flags;
2712 e_flags &= ~ flag;
2713
2714 switch (flag)
2715 {
2716 case EF_ARM_BE8:
2717 strcat (buf, ", BE8");
2718 break;
2719
2720 case EF_ARM_LE8:
2721 strcat (buf, ", LE8");
2722 break;
2723
2724 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2725 strcat (buf, ", soft-float ABI");
2726 break;
2727
2728 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2729 strcat (buf, ", hard-float ABI");
2730 break;
2731
2732 default:
2733 unknown = TRUE;
2734 break;
2735 }
2736 }
2737 break;
2738
2739 case EF_ARM_EABI_UNKNOWN:
2740 strcat (buf, ", GNU EABI");
2741 while (e_flags)
2742 {
2743 unsigned flag;
2744
2745 /* Process flags one bit at a time. */
2746 flag = e_flags & - e_flags;
2747 e_flags &= ~ flag;
2748
2749 switch (flag)
2750 {
2751 case EF_ARM_INTERWORK:
2752 strcat (buf, ", interworking enabled");
2753 break;
2754
2755 case EF_ARM_APCS_26:
2756 strcat (buf, ", uses APCS/26");
2757 break;
2758
2759 case EF_ARM_APCS_FLOAT:
2760 strcat (buf, ", uses APCS/float");
2761 break;
2762
2763 case EF_ARM_PIC:
2764 strcat (buf, ", position independent");
2765 break;
2766
2767 case EF_ARM_ALIGN8:
2768 strcat (buf, ", 8 bit structure alignment");
2769 break;
2770
2771 case EF_ARM_NEW_ABI:
2772 strcat (buf, ", uses new ABI");
2773 break;
2774
2775 case EF_ARM_OLD_ABI:
2776 strcat (buf, ", uses old ABI");
2777 break;
2778
2779 case EF_ARM_SOFT_FLOAT:
2780 strcat (buf, ", software FP");
2781 break;
2782
2783 case EF_ARM_VFP_FLOAT:
2784 strcat (buf, ", VFP");
2785 break;
2786
2787 case EF_ARM_MAVERICK_FLOAT:
2788 strcat (buf, ", Maverick FP");
2789 break;
2790
2791 default:
2792 unknown = TRUE;
2793 break;
2794 }
2795 }
2796 }
2797
2798 if (unknown)
2799 strcat (buf,_(", <unknown>"));
2800}
2801
2802static void
2803decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804{
2805 --size; /* Leave space for null terminator. */
2806
2807 switch (e_flags & EF_AVR_MACH)
2808 {
2809 case E_AVR_MACH_AVR1:
2810 strncat (buf, ", avr:1", size);
2811 break;
2812 case E_AVR_MACH_AVR2:
2813 strncat (buf, ", avr:2", size);
2814 break;
2815 case E_AVR_MACH_AVR25:
2816 strncat (buf, ", avr:25", size);
2817 break;
2818 case E_AVR_MACH_AVR3:
2819 strncat (buf, ", avr:3", size);
2820 break;
2821 case E_AVR_MACH_AVR31:
2822 strncat (buf, ", avr:31", size);
2823 break;
2824 case E_AVR_MACH_AVR35:
2825 strncat (buf, ", avr:35", size);
2826 break;
2827 case E_AVR_MACH_AVR4:
2828 strncat (buf, ", avr:4", size);
2829 break;
2830 case E_AVR_MACH_AVR5:
2831 strncat (buf, ", avr:5", size);
2832 break;
2833 case E_AVR_MACH_AVR51:
2834 strncat (buf, ", avr:51", size);
2835 break;
2836 case E_AVR_MACH_AVR6:
2837 strncat (buf, ", avr:6", size);
2838 break;
2839 case E_AVR_MACH_AVRTINY:
2840 strncat (buf, ", avr:100", size);
2841 break;
2842 case E_AVR_MACH_XMEGA1:
2843 strncat (buf, ", avr:101", size);
2844 break;
2845 case E_AVR_MACH_XMEGA2:
2846 strncat (buf, ", avr:102", size);
2847 break;
2848 case E_AVR_MACH_XMEGA3:
2849 strncat (buf, ", avr:103", size);
2850 break;
2851 case E_AVR_MACH_XMEGA4:
2852 strncat (buf, ", avr:104", size);
2853 break;
2854 case E_AVR_MACH_XMEGA5:
2855 strncat (buf, ", avr:105", size);
2856 break;
2857 case E_AVR_MACH_XMEGA6:
2858 strncat (buf, ", avr:106", size);
2859 break;
2860 case E_AVR_MACH_XMEGA7:
2861 strncat (buf, ", avr:107", size);
2862 break;
2863 default:
2864 strncat (buf, ", avr:<unknown>", size);
2865 break;
2866 }
2867
2868 size -= strlen (buf);
2869 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870 strncat (buf, ", link-relax", size);
2871}
2872
2873static void
2874decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875{
2876 unsigned abi;
2877 unsigned arch;
2878 unsigned config;
2879 unsigned version;
2880 bfd_boolean has_fpu = FALSE;
2881 unsigned int r = 0;
2882
2883 static const char *ABI_STRINGS[] =
2884 {
2885 "ABI v0", /* use r5 as return register; only used in N1213HC */
2886 "ABI v1", /* use r0 as return register */
2887 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888 "ABI v2fp", /* for FPU */
2889 "AABI",
2890 "ABI2 FP+"
2891 };
2892 static const char *VER_STRINGS[] =
2893 {
2894 "Andes ELF V1.3 or older",
2895 "Andes ELF V1.3.1",
2896 "Andes ELF V1.4"
2897 };
2898 static const char *ARCH_STRINGS[] =
2899 {
2900 "",
2901 "Andes Star v1.0",
2902 "Andes Star v2.0",
2903 "Andes Star v3.0",
2904 "Andes Star v3.0m"
2905 };
2906
2907 abi = EF_NDS_ABI & e_flags;
2908 arch = EF_NDS_ARCH & e_flags;
2909 config = EF_NDS_INST & e_flags;
2910 version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912 memset (buf, 0, size);
2913
2914 switch (abi)
2915 {
2916 case E_NDS_ABI_V0:
2917 case E_NDS_ABI_V1:
2918 case E_NDS_ABI_V2:
2919 case E_NDS_ABI_V2FP:
2920 case E_NDS_ABI_AABI:
2921 case E_NDS_ABI_V2FP_PLUS:
2922 /* In case there are holes in the array. */
2923 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924 break;
2925
2926 default:
2927 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928 break;
2929 }
2930
2931 switch (version)
2932 {
2933 case E_NDS32_ELF_VER_1_2:
2934 case E_NDS32_ELF_VER_1_3:
2935 case E_NDS32_ELF_VER_1_4:
2936 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937 break;
2938
2939 default:
2940 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941 break;
2942 }
2943
2944 if (E_NDS_ABI_V0 == abi)
2945 {
2946 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2947 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948 if (arch == E_NDS_ARCH_STAR_V1_0)
2949 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950 return;
2951 }
2952
2953 switch (arch)
2954 {
2955 case E_NDS_ARCH_STAR_V1_0:
2956 case E_NDS_ARCH_STAR_V2_0:
2957 case E_NDS_ARCH_STAR_V3_0:
2958 case E_NDS_ARCH_STAR_V3_M:
2959 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960 break;
2961
2962 default:
2963 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964 /* ARCH version determines how the e_flags are interpreted.
2965 If it is unknown, we cannot proceed. */
2966 return;
2967 }
2968
2969 /* Newer ABI; Now handle architecture specific flags. */
2970 if (arch == E_NDS_ARCH_STAR_V1_0)
2971 {
2972 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976 r += snprintf (buf + r, size -r, ", MAC");
2977
2978 if (config & E_NDS32_HAS_DIV_INST)
2979 r += snprintf (buf + r, size -r, ", DIV");
2980
2981 if (config & E_NDS32_HAS_16BIT_INST)
2982 r += snprintf (buf + r, size -r, ", 16b");
2983 }
2984 else
2985 {
2986 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987 {
2988 if (version <= E_NDS32_ELF_VER_1_3)
2989 r += snprintf (buf + r, size -r, ", [B8]");
2990 else
2991 r += snprintf (buf + r, size -r, ", EX9");
2992 }
2993
2994 if (config & E_NDS32_HAS_MAC_DX_INST)
2995 r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997 if (config & E_NDS32_HAS_DIV_DX_INST)
2998 r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000 if (config & E_NDS32_HAS_16BIT_INST)
3001 {
3002 if (version <= E_NDS32_ELF_VER_1_3)
3003 r += snprintf (buf + r, size -r, ", 16b");
3004 else
3005 r += snprintf (buf + r, size -r, ", IFC");
3006 }
3007 }
3008
3009 if (config & E_NDS32_HAS_EXT_INST)
3010 r += snprintf (buf + r, size -r, ", PERF1");
3011
3012 if (config & E_NDS32_HAS_EXT2_INST)
3013 r += snprintf (buf + r, size -r, ", PERF2");
3014
3015 if (config & E_NDS32_HAS_FPU_INST)
3016 {
3017 has_fpu = TRUE;
3018 r += snprintf (buf + r, size -r, ", FPU_SP");
3019 }
3020
3021 if (config & E_NDS32_HAS_FPU_DP_INST)
3022 {
3023 has_fpu = TRUE;
3024 r += snprintf (buf + r, size -r, ", FPU_DP");
3025 }
3026
3027 if (config & E_NDS32_HAS_FPU_MAC_INST)
3028 {
3029 has_fpu = TRUE;
3030 r += snprintf (buf + r, size -r, ", FPU_MAC");
3031 }
3032
3033 if (has_fpu)
3034 {
3035 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036 {
3037 case E_NDS32_FPU_REG_8SP_4DP:
3038 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039 break;
3040 case E_NDS32_FPU_REG_16SP_8DP:
3041 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042 break;
3043 case E_NDS32_FPU_REG_32SP_16DP:
3044 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045 break;
3046 case E_NDS32_FPU_REG_32SP_32DP:
3047 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048 break;
3049 }
3050 }
3051
3052 if (config & E_NDS32_HAS_AUDIO_INST)
3053 r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055 if (config & E_NDS32_HAS_STRING_INST)
3056 r += snprintf (buf + r, size -r, ", STR");
3057
3058 if (config & E_NDS32_HAS_REDUCED_REGS)
3059 r += snprintf (buf + r, size -r, ", 16REG");
3060
3061 if (config & E_NDS32_HAS_VIDEO_INST)
3062 {
3063 if (version <= E_NDS32_ELF_VER_1_3)
3064 r += snprintf (buf + r, size -r, ", VIDEO");
3065 else
3066 r += snprintf (buf + r, size -r, ", SATURATION");
3067 }
3068
3069 if (config & E_NDS32_HAS_ENCRIPT_INST)
3070 r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072 if (config & E_NDS32_HAS_L2C_INST)
3073 r += snprintf (buf + r, size -r, ", L2C");
3074}
3075
3076static char *
3077get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078{
3079 static char buf[1024];
3080
3081 buf[0] = '\0';
3082
3083 if (e_flags)
3084 {
3085 switch (e_machine)
3086 {
3087 default:
3088 break;
3089
3090 case EM_ARC_COMPACT2:
3091 case EM_ARC_COMPACT:
3092 decode_ARC_machine_flags (e_flags, e_machine, buf);
3093 break;
3094
3095 case EM_ARM:
3096 decode_ARM_machine_flags (e_flags, buf);
3097 break;
3098
3099 case EM_AVR:
3100 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101 break;
3102
3103 case EM_BLACKFIN:
3104 if (e_flags & EF_BFIN_PIC)
3105 strcat (buf, ", PIC");
3106
3107 if (e_flags & EF_BFIN_FDPIC)
3108 strcat (buf, ", FDPIC");
3109
3110 if (e_flags & EF_BFIN_CODE_IN_L1)
3111 strcat (buf, ", code in L1");
3112
3113 if (e_flags & EF_BFIN_DATA_IN_L1)
3114 strcat (buf, ", data in L1");
3115
3116 break;
3117
3118 case EM_CYGNUS_FRV:
3119 switch (e_flags & EF_FRV_CPU_MASK)
3120 {
3121 case EF_FRV_CPU_GENERIC:
3122 break;
3123
3124 default:
3125 strcat (buf, ", fr???");
3126 break;
3127
3128 case EF_FRV_CPU_FR300:
3129 strcat (buf, ", fr300");
3130 break;
3131
3132 case EF_FRV_CPU_FR400:
3133 strcat (buf, ", fr400");
3134 break;
3135 case EF_FRV_CPU_FR405:
3136 strcat (buf, ", fr405");
3137 break;
3138
3139 case EF_FRV_CPU_FR450:
3140 strcat (buf, ", fr450");
3141 break;
3142
3143 case EF_FRV_CPU_FR500:
3144 strcat (buf, ", fr500");
3145 break;
3146 case EF_FRV_CPU_FR550:
3147 strcat (buf, ", fr550");
3148 break;
3149
3150 case EF_FRV_CPU_SIMPLE:
3151 strcat (buf, ", simple");
3152 break;
3153 case EF_FRV_CPU_TOMCAT:
3154 strcat (buf, ", tomcat");
3155 break;
3156 }
3157 break;
3158
3159 case EM_68K:
3160 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161 strcat (buf, ", m68000");
3162 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163 strcat (buf, ", cpu32");
3164 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165 strcat (buf, ", fido_a");
3166 else
3167 {
3168 char const * isa = _("unknown");
3169 char const * mac = _("unknown mac");
3170 char const * additional = NULL;
3171
3172 switch (e_flags & EF_M68K_CF_ISA_MASK)
3173 {
3174 case EF_M68K_CF_ISA_A_NODIV:
3175 isa = "A";
3176 additional = ", nodiv";
3177 break;
3178 case EF_M68K_CF_ISA_A:
3179 isa = "A";
3180 break;
3181 case EF_M68K_CF_ISA_A_PLUS:
3182 isa = "A+";
3183 break;
3184 case EF_M68K_CF_ISA_B_NOUSP:
3185 isa = "B";
3186 additional = ", nousp";
3187 break;
3188 case EF_M68K_CF_ISA_B:
3189 isa = "B";
3190 break;
3191 case EF_M68K_CF_ISA_C:
3192 isa = "C";
3193 break;
3194 case EF_M68K_CF_ISA_C_NODIV:
3195 isa = "C";
3196 additional = ", nodiv";
3197 break;
3198 }
3199 strcat (buf, ", cf, isa ");
3200 strcat (buf, isa);
3201 if (additional)
3202 strcat (buf, additional);
3203 if (e_flags & EF_M68K_CF_FLOAT)
3204 strcat (buf, ", float");
3205 switch (e_flags & EF_M68K_CF_MAC_MASK)
3206 {
3207 case 0:
3208 mac = NULL;
3209 break;
3210 case EF_M68K_CF_MAC:
3211 mac = "mac";
3212 break;
3213 case EF_M68K_CF_EMAC:
3214 mac = "emac";
3215 break;
3216 case EF_M68K_CF_EMAC_B:
3217 mac = "emac_b";
3218 break;
3219 }
3220 if (mac)
3221 {
3222 strcat (buf, ", ");
3223 strcat (buf, mac);
3224 }
3225 }
3226 break;
3227
3228 case EM_CYGNUS_MEP:
3229 switch (e_flags & EF_MEP_CPU_MASK)
3230 {
3231 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238 }
3239
3240 switch (e_flags & EF_MEP_COP_MASK)
3241 {
3242 case EF_MEP_COP_NONE: break;
3243 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247 default: strcat (buf, _("<unknown MeP copro type>")); break;
3248 }
3249
3250 if (e_flags & EF_MEP_LIBRARY)
3251 strcat (buf, ", Built for Library");
3252
3253 if (e_flags & EF_MEP_INDEX_MASK)
3254 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255 e_flags & EF_MEP_INDEX_MASK);
3256
3257 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259 e_flags & ~ EF_MEP_ALL_FLAGS);
3260 break;
3261
3262 case EM_PPC:
3263 if (e_flags & EF_PPC_EMB)
3264 strcat (buf, ", emb");
3265
3266 if (e_flags & EF_PPC_RELOCATABLE)
3267 strcat (buf, _(", relocatable"));
3268
3269 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270 strcat (buf, _(", relocatable-lib"));
3271 break;
3272
3273 case EM_PPC64:
3274 if (e_flags & EF_PPC64_ABI)
3275 {
3276 char abi[] = ", abiv0";
3277
3278 abi[6] += e_flags & EF_PPC64_ABI;
3279 strcat (buf, abi);
3280 }
3281 break;
3282
3283 case EM_V800:
3284 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285 strcat (buf, ", RH850 ABI");
3286
3287 if (e_flags & EF_V800_850E3)
3288 strcat (buf, ", V3 architecture");
3289
3290 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291 strcat (buf, ", FPU not used");
3292
3293 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294 strcat (buf, ", regmode: COMMON");
3295
3296 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297 strcat (buf, ", r4 not used");
3298
3299 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300 strcat (buf, ", r30 not used");
3301
3302 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303 strcat (buf, ", r5 not used");
3304
3305 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306 strcat (buf, ", r2 not used");
3307
3308 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309 {
3310 switch (e_flags & - e_flags)
3311 {
3312 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324 default: break;
3325 }
3326 }
3327 break;
3328
3329 case EM_V850:
3330 case EM_CYGNUS_V850:
3331 switch (e_flags & EF_V850_ARCH)
3332 {
3333 case E_V850E3V5_ARCH:
3334 strcat (buf, ", v850e3v5");
3335 break;
3336 case E_V850E2V3_ARCH:
3337 strcat (buf, ", v850e2v3");
3338 break;
3339 case E_V850E2_ARCH:
3340 strcat (buf, ", v850e2");
3341 break;
3342 case E_V850E1_ARCH:
3343 strcat (buf, ", v850e1");
3344 break;
3345 case E_V850E_ARCH:
3346 strcat (buf, ", v850e");
3347 break;
3348 case E_V850_ARCH:
3349 strcat (buf, ", v850");
3350 break;
3351 default:
3352 strcat (buf, _(", unknown v850 architecture variant"));
3353 break;
3354 }
3355 break;
3356
3357 case EM_M32R:
3358 case EM_CYGNUS_M32R:
3359 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360 strcat (buf, ", m32r");
3361 break;
3362
3363 case EM_MIPS:
3364 case EM_MIPS_RS3_LE:
3365 if (e_flags & EF_MIPS_NOREORDER)
3366 strcat (buf, ", noreorder");
3367
3368 if (e_flags & EF_MIPS_PIC)
3369 strcat (buf, ", pic");
3370
3371 if (e_flags & EF_MIPS_CPIC)
3372 strcat (buf, ", cpic");
3373
3374 if (e_flags & EF_MIPS_UCODE)
3375 strcat (buf, ", ugen_reserved");
3376
3377 if (e_flags & EF_MIPS_ABI2)
3378 strcat (buf, ", abi2");
3379
3380 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381 strcat (buf, ", odk first");
3382
3383 if (e_flags & EF_MIPS_32BITMODE)
3384 strcat (buf, ", 32bitmode");
3385
3386 if (e_flags & EF_MIPS_NAN2008)
3387 strcat (buf, ", nan2008");
3388
3389 if (e_flags & EF_MIPS_FP64)
3390 strcat (buf, ", fp64");
3391
3392 switch ((e_flags & EF_MIPS_MACH))
3393 {
3394 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3404 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3408 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3409 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3410 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3411 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3412 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3413 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3414 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3415 case 0:
3416 /* We simply ignore the field in this case to avoid confusion:
3417 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3418 extension. */
3419 break;
3420 default: strcat (buf, _(", unknown CPU")); break;
3421 }
3422
3423 switch ((e_flags & EF_MIPS_ABI))
3424 {
3425 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3426 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3427 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3428 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3429 case 0:
3430 /* We simply ignore the field in this case to avoid confusion:
3431 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3432 This means it is likely to be an o32 file, but not for
3433 sure. */
3434 break;
3435 default: strcat (buf, _(", unknown ABI")); break;
3436 }
3437
3438 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3439 strcat (buf, ", mdmx");
3440
3441 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3442 strcat (buf, ", mips16");
3443
3444 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3445 strcat (buf, ", micromips");
3446
3447 switch ((e_flags & EF_MIPS_ARCH))
3448 {
3449 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3450 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3451 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3452 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3453 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3454 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3455 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3456 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3457 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3458 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3459 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3460 default: strcat (buf, _(", unknown ISA")); break;
3461 }
3462 break;
3463
3464 case EM_NDS32:
3465 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3466 break;
3467
3468 case EM_NFP:
3469 switch (EF_NFP_MACH (e_flags))
3470 {
3471 case E_NFP_MACH_3200:
3472 strcat (buf, ", NFP-32xx");
3473 break;
3474 case E_NFP_MACH_6000:
3475 strcat (buf, ", NFP-6xxx");
3476 break;
3477 }
3478 break;
3479
3480 case EM_RISCV:
3481 if (e_flags & EF_RISCV_RVC)
3482 strcat (buf, ", RVC");
3483
3484 if (e_flags & EF_RISCV_RVE)
3485 strcat (buf, ", RVE");
3486
3487 switch (e_flags & EF_RISCV_FLOAT_ABI)
3488 {
3489 case EF_RISCV_FLOAT_ABI_SOFT:
3490 strcat (buf, ", soft-float ABI");
3491 break;
3492
3493 case EF_RISCV_FLOAT_ABI_SINGLE:
3494 strcat (buf, ", single-float ABI");
3495 break;
3496
3497 case EF_RISCV_FLOAT_ABI_DOUBLE:
3498 strcat (buf, ", double-float ABI");
3499 break;
3500
3501 case EF_RISCV_FLOAT_ABI_QUAD:
3502 strcat (buf, ", quad-float ABI");
3503 break;
3504 }
3505 break;
3506
3507 case EM_SH:
3508 switch ((e_flags & EF_SH_MACH_MASK))
3509 {
3510 case EF_SH1: strcat (buf, ", sh1"); break;
3511 case EF_SH2: strcat (buf, ", sh2"); break;
3512 case EF_SH3: strcat (buf, ", sh3"); break;
3513 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3514 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3515 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3516 case EF_SH3E: strcat (buf, ", sh3e"); break;
3517 case EF_SH4: strcat (buf, ", sh4"); break;
3518 case EF_SH5: strcat (buf, ", sh5"); break;
3519 case EF_SH2E: strcat (buf, ", sh2e"); break;
3520 case EF_SH4A: strcat (buf, ", sh4a"); break;
3521 case EF_SH2A: strcat (buf, ", sh2a"); break;
3522 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3523 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3524 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3525 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3526 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3527 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3528 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3529 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3530 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3531 default: strcat (buf, _(", unknown ISA")); break;
3532 }
3533
3534 if (e_flags & EF_SH_PIC)
3535 strcat (buf, ", pic");
3536
3537 if (e_flags & EF_SH_FDPIC)
3538 strcat (buf, ", fdpic");
3539 break;
3540
3541 case EM_OR1K:
3542 if (e_flags & EF_OR1K_NODELAY)
3543 strcat (buf, ", no delay");
3544 break;
3545
3546 case EM_SPARCV9:
3547 if (e_flags & EF_SPARC_32PLUS)
3548 strcat (buf, ", v8+");
3549
3550 if (e_flags & EF_SPARC_SUN_US1)
3551 strcat (buf, ", ultrasparcI");
3552
3553 if (e_flags & EF_SPARC_SUN_US3)
3554 strcat (buf, ", ultrasparcIII");
3555
3556 if (e_flags & EF_SPARC_HAL_R1)
3557 strcat (buf, ", halr1");
3558
3559 if (e_flags & EF_SPARC_LEDATA)
3560 strcat (buf, ", ledata");
3561
3562 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3563 strcat (buf, ", tso");
3564
3565 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3566 strcat (buf, ", pso");
3567
3568 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3569 strcat (buf, ", rmo");
3570 break;
3571
3572 case EM_PARISC:
3573 switch (e_flags & EF_PARISC_ARCH)
3574 {
3575 case EFA_PARISC_1_0:
3576 strcpy (buf, ", PA-RISC 1.0");
3577 break;
3578 case EFA_PARISC_1_1:
3579 strcpy (buf, ", PA-RISC 1.1");
3580 break;
3581 case EFA_PARISC_2_0:
3582 strcpy (buf, ", PA-RISC 2.0");
3583 break;
3584 default:
3585 break;
3586 }
3587 if (e_flags & EF_PARISC_TRAPNIL)
3588 strcat (buf, ", trapnil");
3589 if (e_flags & EF_PARISC_EXT)
3590 strcat (buf, ", ext");
3591 if (e_flags & EF_PARISC_LSB)
3592 strcat (buf, ", lsb");
3593 if (e_flags & EF_PARISC_WIDE)
3594 strcat (buf, ", wide");
3595 if (e_flags & EF_PARISC_NO_KABP)
3596 strcat (buf, ", no kabp");
3597 if (e_flags & EF_PARISC_LAZYSWAP)
3598 strcat (buf, ", lazyswap");
3599 break;
3600
3601 case EM_PJ:
3602 case EM_PJ_OLD:
3603 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3604 strcat (buf, ", new calling convention");
3605
3606 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3607 strcat (buf, ", gnu calling convention");
3608 break;
3609
3610 case EM_IA_64:
3611 if ((e_flags & EF_IA_64_ABI64))
3612 strcat (buf, ", 64-bit");
3613 else
3614 strcat (buf, ", 32-bit");
3615 if ((e_flags & EF_IA_64_REDUCEDFP))
3616 strcat (buf, ", reduced fp model");
3617 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3618 strcat (buf, ", no function descriptors, constant gp");
3619 else if ((e_flags & EF_IA_64_CONS_GP))
3620 strcat (buf, ", constant gp");
3621 if ((e_flags & EF_IA_64_ABSOLUTE))
3622 strcat (buf, ", absolute");
3623 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3624 {
3625 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3626 strcat (buf, ", vms_linkages");
3627 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3628 {
3629 case EF_IA_64_VMS_COMCOD_SUCCESS:
3630 break;
3631 case EF_IA_64_VMS_COMCOD_WARNING:
3632 strcat (buf, ", warning");
3633 break;
3634 case EF_IA_64_VMS_COMCOD_ERROR:
3635 strcat (buf, ", error");
3636 break;
3637 case EF_IA_64_VMS_COMCOD_ABORT:
3638 strcat (buf, ", abort");
3639 break;
3640 default:
3641 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3642 e_flags & EF_IA_64_VMS_COMCOD);
3643 strcat (buf, ", <unknown>");
3644 }
3645 }
3646 break;
3647
3648 case EM_VAX:
3649 if ((e_flags & EF_VAX_NONPIC))
3650 strcat (buf, ", non-PIC");
3651 if ((e_flags & EF_VAX_DFLOAT))
3652 strcat (buf, ", D-Float");
3653 if ((e_flags & EF_VAX_GFLOAT))
3654 strcat (buf, ", G-Float");
3655 break;
3656
3657 case EM_VISIUM:
3658 if (e_flags & EF_VISIUM_ARCH_MCM)
3659 strcat (buf, ", mcm");
3660 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3661 strcat (buf, ", mcm24");
3662 if (e_flags & EF_VISIUM_ARCH_GR6)
3663 strcat (buf, ", gr6");
3664 break;
3665
3666 case EM_RL78:
3667 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3668 {
3669 case E_FLAG_RL78_ANY_CPU: break;
3670 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3671 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3672 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3673 }
3674 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3675 strcat (buf, ", 64-bit doubles");
3676 break;
3677
3678 case EM_RX:
3679 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3680 strcat (buf, ", 64-bit doubles");
3681 if (e_flags & E_FLAG_RX_DSP)
3682 strcat (buf, ", dsp");
3683 if (e_flags & E_FLAG_RX_PID)
3684 strcat (buf, ", pid");
3685 if (e_flags & E_FLAG_RX_ABI)
3686 strcat (buf, ", RX ABI");
3687 if (e_flags & E_FLAG_RX_SINSNS_SET)
3688 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3689 ? ", uses String instructions" : ", bans String instructions");
3690 if (e_flags & E_FLAG_RX_V2)
3691 strcat (buf, ", V2");
3692 if (e_flags & E_FLAG_RX_V3)
3693 strcat (buf, ", V3");
3694 break;
3695
3696 case EM_S390:
3697 if (e_flags & EF_S390_HIGH_GPRS)
3698 strcat (buf, ", highgprs");
3699 break;
3700
3701 case EM_TI_C6000:
3702 if ((e_flags & EF_C6000_REL))
3703 strcat (buf, ", relocatable module");
3704 break;
3705
3706 case EM_MSP430:
3707 strcat (buf, _(": architecture variant: "));
3708 switch (e_flags & EF_MSP430_MACH)
3709 {
3710 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3711 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3712 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3713 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3714 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3715 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3716 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3717 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3718 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3719 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3720 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3721 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3722 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3723 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3724 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3725 default:
3726 strcat (buf, _(": unknown")); break;
3727 }
3728
3729 if (e_flags & ~ EF_MSP430_MACH)
3730 strcat (buf, _(": unknown extra flag bits also present"));
3731 }
3732 }
3733
3734 return buf;
3735}
3736
3737static const char *
3738get_osabi_name (Filedata * filedata, unsigned int osabi)
3739{
3740 static char buff[32];
3741
3742 switch (osabi)
3743 {
3744 case ELFOSABI_NONE: return "UNIX - System V";
3745 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3746 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3747 case ELFOSABI_GNU: return "UNIX - GNU";
3748 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3749 case ELFOSABI_AIX: return "UNIX - AIX";
3750 case ELFOSABI_IRIX: return "UNIX - IRIX";
3751 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3752 case ELFOSABI_TRU64: return "UNIX - TRU64";
3753 case ELFOSABI_MODESTO: return "Novell - Modesto";
3754 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3755 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3756 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3757 case ELFOSABI_AROS: return "AROS";
3758 case ELFOSABI_FENIXOS: return "FenixOS";
3759 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3760 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3761 default:
3762 if (osabi >= 64)
3763 switch (filedata->file_header.e_machine)
3764 {
3765 case EM_ARM:
3766 switch (osabi)
3767 {
3768 case ELFOSABI_ARM: return "ARM";
3769 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3770 default:
3771 break;
3772 }
3773 break;
3774
3775 case EM_MSP430:
3776 case EM_MSP430_OLD:
3777 case EM_VISIUM:
3778 switch (osabi)
3779 {
3780 case ELFOSABI_STANDALONE: return _("Standalone App");
3781 default:
3782 break;
3783 }
3784 break;
3785
3786 case EM_TI_C6000:
3787 switch (osabi)
3788 {
3789 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3790 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3791 default:
3792 break;
3793 }
3794 break;
3795
3796 default:
3797 break;
3798 }
3799 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3800 return buff;
3801 }
3802}
3803
3804static const char *
3805get_aarch64_segment_type (unsigned long type)
3806{
3807 switch (type)
3808 {
3809 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3810 default: return NULL;
3811 }
3812}
3813
3814static const char *
3815get_arm_segment_type (unsigned long type)
3816{
3817 switch (type)
3818 {
3819 case PT_ARM_EXIDX: return "EXIDX";
3820 default: return NULL;
3821 }
3822}
3823
3824static const char *
3825get_s390_segment_type (unsigned long type)
3826{
3827 switch (type)
3828 {
3829 case PT_S390_PGSTE: return "S390_PGSTE";
3830 default: return NULL;
3831 }
3832}
3833
3834static const char *
3835get_mips_segment_type (unsigned long type)
3836{
3837 switch (type)
3838 {
3839 case PT_MIPS_REGINFO: return "REGINFO";
3840 case PT_MIPS_RTPROC: return "RTPROC";
3841 case PT_MIPS_OPTIONS: return "OPTIONS";
3842 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3843 default: return NULL;
3844 }
3845}
3846
3847static const char *
3848get_parisc_segment_type (unsigned long type)
3849{
3850 switch (type)
3851 {
3852 case PT_HP_TLS: return "HP_TLS";
3853 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3854 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3855 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3856 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3857 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3858 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3859 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3860 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3861 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3862 case PT_HP_PARALLEL: return "HP_PARALLEL";
3863 case PT_HP_FASTBIND: return "HP_FASTBIND";
3864 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3865 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3866 case PT_HP_STACK: return "HP_STACK";
3867 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3868 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3869 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3870 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3871 default: return NULL;
3872 }
3873}
3874
3875static const char *
3876get_ia64_segment_type (unsigned long type)
3877{
3878 switch (type)
3879 {
3880 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3881 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3882 case PT_HP_TLS: return "HP_TLS";
3883 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3884 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3885 case PT_IA_64_HP_STACK: return "HP_STACK";
3886 default: return NULL;
3887 }
3888}
3889
3890static const char *
3891get_tic6x_segment_type (unsigned long type)
3892{
3893 switch (type)
3894 {
3895 case PT_C6000_PHATTR: return "C6000_PHATTR";
3896 default: return NULL;
3897 }
3898}
3899
3900static const char *
3901get_solaris_segment_type (unsigned long type)
3902{
3903 switch (type)
3904 {
3905 case 0x6464e550: return "PT_SUNW_UNWIND";
3906 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3907 case 0x6ffffff7: return "PT_LOSUNW";
3908 case 0x6ffffffa: return "PT_SUNWBSS";
3909 case 0x6ffffffb: return "PT_SUNWSTACK";
3910 case 0x6ffffffc: return "PT_SUNWDTRACE";
3911 case 0x6ffffffd: return "PT_SUNWCAP";
3912 case 0x6fffffff: return "PT_HISUNW";
3913 default: return NULL;
3914 }
3915}
3916
3917static const char *
3918get_segment_type (Filedata * filedata, unsigned long p_type)
3919{
3920 static char buff[32];
3921
3922 switch (p_type)
3923 {
3924 case PT_NULL: return "NULL";
3925 case PT_LOAD: return "LOAD";
3926 case PT_DYNAMIC: return "DYNAMIC";
3927 case PT_INTERP: return "INTERP";
3928 case PT_NOTE: return "NOTE";
3929 case PT_SHLIB: return "SHLIB";
3930 case PT_PHDR: return "PHDR";
3931 case PT_TLS: return "TLS";
3932 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3933 case PT_GNU_STACK: return "GNU_STACK";
3934 case PT_GNU_RELRO: return "GNU_RELRO";
3935 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3936
3937 default:
3938 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3939 {
3940 sprintf (buff, "GNU_MBIND+%#lx",
3941 p_type - PT_GNU_MBIND_LO);
3942 }
3943 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3944 {
3945 const char * result;
3946
3947 switch (filedata->file_header.e_machine)
3948 {
3949 case EM_AARCH64:
3950 result = get_aarch64_segment_type (p_type);
3951 break;
3952 case EM_ARM:
3953 result = get_arm_segment_type (p_type);
3954 break;
3955 case EM_MIPS:
3956 case EM_MIPS_RS3_LE:
3957 result = get_mips_segment_type (p_type);
3958 break;
3959 case EM_PARISC:
3960 result = get_parisc_segment_type (p_type);
3961 break;
3962 case EM_IA_64:
3963 result = get_ia64_segment_type (p_type);
3964 break;
3965 case EM_TI_C6000:
3966 result = get_tic6x_segment_type (p_type);
3967 break;
3968 case EM_S390:
3969 case EM_S390_OLD:
3970 result = get_s390_segment_type (p_type);
3971 break;
3972 default:
3973 result = NULL;
3974 break;
3975 }
3976
3977 if (result != NULL)
3978 return result;
3979
3980 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3981 }
3982 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3983 {
3984 const char * result;
3985
3986 switch (filedata->file_header.e_machine)
3987 {
3988 case EM_PARISC:
3989 result = get_parisc_segment_type (p_type);
3990 break;
3991 case EM_IA_64:
3992 result = get_ia64_segment_type (p_type);
3993 break;
3994 default:
3995 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3996 result = get_solaris_segment_type (p_type);
3997 else
3998 result = NULL;
3999 break;
4000 }
4001
4002 if (result != NULL)
4003 return result;
4004
4005 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4006 }
4007 else
4008 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4009
4010 return buff;
4011 }
4012}
4013
4014static const char *
4015get_arc_section_type_name (unsigned int sh_type)
4016{
4017 switch (sh_type)
4018 {
4019 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4020 default:
4021 break;
4022 }
4023 return NULL;
4024}
4025
4026static const char *
4027get_mips_section_type_name (unsigned int sh_type)
4028{
4029 switch (sh_type)
4030 {
4031 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4032 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4033 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4034 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4035 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4036 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4037 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4038 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4039 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4040 case SHT_MIPS_RELD: return "MIPS_RELD";
4041 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4042 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4043 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4044 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4045 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4046 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4047 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4048 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4049 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4050 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4051 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4052 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4053 case SHT_MIPS_LINE: return "MIPS_LINE";
4054 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4055 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4056 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4057 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4058 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4059 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4060 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4061 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4062 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4063 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4064 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4065 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4066 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4067 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4068 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4069 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4070 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4071 default:
4072 break;
4073 }
4074 return NULL;
4075}
4076
4077static const char *
4078get_parisc_section_type_name (unsigned int sh_type)
4079{
4080 switch (sh_type)
4081 {
4082 case SHT_PARISC_EXT: return "PARISC_EXT";
4083 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4084 case SHT_PARISC_DOC: return "PARISC_DOC";
4085 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4086 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4087 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4088 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4089 default: return NULL;
4090 }
4091}
4092
4093static const char *
4094get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4095{
4096 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4097 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4098 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4099
4100 switch (sh_type)
4101 {
4102 case SHT_IA_64_EXT: return "IA_64_EXT";
4103 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4104 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4105 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4106 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4107 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4108 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4109 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4110 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4111 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4112 default:
4113 break;
4114 }
4115 return NULL;
4116}
4117
4118static const char *
4119get_x86_64_section_type_name (unsigned int sh_type)
4120{
4121 switch (sh_type)
4122 {
4123 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4124 default: return NULL;
4125 }
4126}
4127
4128static const char *
4129get_aarch64_section_type_name (unsigned int sh_type)
4130{
4131 switch (sh_type)
4132 {
4133 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4134 default: return NULL;
4135 }
4136}
4137
4138static const char *
4139get_arm_section_type_name (unsigned int sh_type)
4140{
4141 switch (sh_type)
4142 {
4143 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4144 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4145 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4146 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4147 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4148 default: return NULL;
4149 }
4150}
4151
4152static const char *
4153get_tic6x_section_type_name (unsigned int sh_type)
4154{
4155 switch (sh_type)
4156 {
4157 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4158 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4159 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4160 case SHT_TI_ICODE: return "TI_ICODE";
4161 case SHT_TI_XREF: return "TI_XREF";
4162 case SHT_TI_HANDLER: return "TI_HANDLER";
4163 case SHT_TI_INITINFO: return "TI_INITINFO";
4164 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4165 default: return NULL;
4166 }
4167}
4168
4169static const char *
4170get_msp430x_section_type_name (unsigned int sh_type)
4171{
4172 switch (sh_type)
4173 {
4174 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4175 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4176 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4177 default: return NULL;
4178 }
4179}
4180
4181static const char *
4182get_nfp_section_type_name (unsigned int sh_type)
4183{
4184 switch (sh_type)
4185 {
4186 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4187 case SHT_NFP_INITREG: return "NFP_INITREG";
4188 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4189 default: return NULL;
4190 }
4191}
4192
4193static const char *
4194get_v850_section_type_name (unsigned int sh_type)
4195{
4196 switch (sh_type)
4197 {
4198 case SHT_V850_SCOMMON: return "V850 Small Common";
4199 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4200 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4201 case SHT_RENESAS_IOP: return "RENESAS IOP";
4202 case SHT_RENESAS_INFO: return "RENESAS INFO";
4203 default: return NULL;
4204 }
4205}
4206
4207static const char *
4208get_section_type_name (Filedata * filedata, unsigned int sh_type)
4209{
4210 static char buff[32];
4211 const char * result;
4212
4213 switch (sh_type)
4214 {
4215 case SHT_NULL: return "NULL";
4216 case SHT_PROGBITS: return "PROGBITS";
4217 case SHT_SYMTAB: return "SYMTAB";
4218 case SHT_STRTAB: return "STRTAB";
4219 case SHT_RELA: return "RELA";
4220 case SHT_HASH: return "HASH";
4221 case SHT_DYNAMIC: return "DYNAMIC";
4222 case SHT_NOTE: return "NOTE";
4223 case SHT_NOBITS: return "NOBITS";
4224 case SHT_REL: return "REL";
4225 case SHT_SHLIB: return "SHLIB";
4226 case SHT_DYNSYM: return "DYNSYM";
4227 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4228 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4229 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4230 case SHT_GNU_HASH: return "GNU_HASH";
4231 case SHT_GROUP: return "GROUP";
4232 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4233 case SHT_GNU_verdef: return "VERDEF";
4234 case SHT_GNU_verneed: return "VERNEED";
4235 case SHT_GNU_versym: return "VERSYM";
4236 case 0x6ffffff0: return "VERSYM";
4237 case 0x6ffffffc: return "VERDEF";
4238 case 0x7ffffffd: return "AUXILIARY";
4239 case 0x7fffffff: return "FILTER";
4240 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4241
4242 default:
4243 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4244 {
4245 switch (filedata->file_header.e_machine)
4246 {
4247 case EM_ARC:
4248 case EM_ARC_COMPACT:
4249 case EM_ARC_COMPACT2:
4250 result = get_arc_section_type_name (sh_type);
4251 break;
4252 case EM_MIPS:
4253 case EM_MIPS_RS3_LE:
4254 result = get_mips_section_type_name (sh_type);
4255 break;
4256 case EM_PARISC:
4257 result = get_parisc_section_type_name (sh_type);
4258 break;
4259 case EM_IA_64:
4260 result = get_ia64_section_type_name (filedata, sh_type);
4261 break;
4262 case EM_X86_64:
4263 case EM_L1OM:
4264 case EM_K1OM:
4265 result = get_x86_64_section_type_name (sh_type);
4266 break;
4267 case EM_AARCH64:
4268 result = get_aarch64_section_type_name (sh_type);
4269 break;
4270 case EM_ARM:
4271 result = get_arm_section_type_name (sh_type);
4272 break;
4273 case EM_TI_C6000:
4274 result = get_tic6x_section_type_name (sh_type);
4275 break;
4276 case EM_MSP430:
4277 result = get_msp430x_section_type_name (sh_type);
4278 break;
4279 case EM_NFP:
4280 result = get_nfp_section_type_name (sh_type);
4281 break;
4282 case EM_V800:
4283 case EM_V850:
4284 case EM_CYGNUS_V850:
4285 result = get_v850_section_type_name (sh_type);
4286 break;
4287 default:
4288 result = NULL;
4289 break;
4290 }
4291
4292 if (result != NULL)
4293 return result;
4294
4295 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4296 }
4297 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4298 {
4299 switch (filedata->file_header.e_machine)
4300 {
4301 case EM_IA_64:
4302 result = get_ia64_section_type_name (filedata, sh_type);
4303 break;
4304 default:
4305 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4306 result = get_solaris_section_type (sh_type);
4307 else
4308 {
4309 switch (sh_type)
4310 {
4311 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4312 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4313 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4314 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4315 default:
4316 result = NULL;
4317 break;
4318 }
4319 }
4320 break;
4321 }
4322
4323 if (result != NULL)
4324 return result;
4325
4326 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4327 }
4328 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4329 {
4330 switch (filedata->file_header.e_machine)
4331 {
4332 case EM_V800:
4333 case EM_V850:
4334 case EM_CYGNUS_V850:
4335 result = get_v850_section_type_name (sh_type);
4336 break;
4337 default:
4338 result = NULL;
4339 break;
4340 }
4341
4342 if (result != NULL)
4343 return result;
4344
4345 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4346 }
4347 else
4348 /* This message is probably going to be displayed in a 15
4349 character wide field, so put the hex value first. */
4350 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4351
4352 return buff;
4353 }
4354}
4355
4356#define OPTION_DEBUG_DUMP 512
4357#define OPTION_DYN_SYMS 513
4358#define OPTION_DWARF_DEPTH 514
4359#define OPTION_DWARF_START 515
4360#define OPTION_DWARF_CHECK 516
4361
4362static struct option options[] =
4363{
4364 {"all", no_argument, 0, 'a'},
4365 {"file-header", no_argument, 0, 'h'},
4366 {"program-headers", no_argument, 0, 'l'},
4367 {"headers", no_argument, 0, 'e'},
4368 {"histogram", no_argument, 0, 'I'},
4369 {"segments", no_argument, 0, 'l'},
4370 {"sections", no_argument, 0, 'S'},
4371 {"section-headers", no_argument, 0, 'S'},
4372 {"section-groups", no_argument, 0, 'g'},
4373 {"section-details", no_argument, 0, 't'},
4374 {"full-section-name",no_argument, 0, 'N'},
4375 {"symbols", no_argument, 0, 's'},
4376 {"syms", no_argument, 0, 's'},
4377 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4378 {"relocs", no_argument, 0, 'r'},
4379 {"notes", no_argument, 0, 'n'},
4380 {"dynamic", no_argument, 0, 'd'},
4381 {"arch-specific", no_argument, 0, 'A'},
4382 {"version-info", no_argument, 0, 'V'},
4383 {"use-dynamic", no_argument, 0, 'D'},
4384 {"unwind", no_argument, 0, 'u'},
4385 {"archive-index", no_argument, 0, 'c'},
4386 {"hex-dump", required_argument, 0, 'x'},
4387 {"relocated-dump", required_argument, 0, 'R'},
4388 {"string-dump", required_argument, 0, 'p'},
4389 {"decompress", no_argument, 0, 'z'},
4390#ifdef SUPPORT_DISASSEMBLY
4391 {"instruction-dump", required_argument, 0, 'i'},
4392#endif
4393 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4394
4395 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4396 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4397 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4398
4399 {"version", no_argument, 0, 'v'},
4400 {"wide", no_argument, 0, 'W'},
4401 {"help", no_argument, 0, 'H'},
4402 {0, no_argument, 0, 0}
4403};
4404
4405static void
4406usage (FILE * stream)
4407{
4408 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4409 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4410 fprintf (stream, _(" Options are:\n\
4411 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4412 -h --file-header Display the ELF file header\n\
4413 -l --program-headers Display the program headers\n\
4414 --segments An alias for --program-headers\n\
4415 -S --section-headers Display the sections' header\n\
4416 --sections An alias for --section-headers\n\
4417 -g --section-groups Display the section groups\n\
4418 -t --section-details Display the section details\n\
4419 -e --headers Equivalent to: -h -l -S\n\
4420 -s --syms Display the symbol table\n\
4421 --symbols An alias for --syms\n\
4422 --dyn-syms Display the dynamic symbol table\n\
4423 -n --notes Display the core notes (if present)\n\
4424 -r --relocs Display the relocations (if present)\n\
4425 -u --unwind Display the unwind info (if present)\n\
4426 -d --dynamic Display the dynamic section (if present)\n\
4427 -V --version-info Display the version sections (if present)\n\
4428 -A --arch-specific Display architecture specific information (if any)\n\
4429 -c --archive-index Display the symbol/file index in an archive\n\
4430 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4431 -x --hex-dump=<number|name>\n\
4432 Dump the contents of section <number|name> as bytes\n\
4433 -p --string-dump=<number|name>\n\
4434 Dump the contents of section <number|name> as strings\n\
4435 -R --relocated-dump=<number|name>\n\
4436 Dump the contents of section <number|name> as relocated bytes\n\
4437 -z --decompress Decompress section before dumping it\n\
4438 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4439 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4440 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4441 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4442 =addr,=cu_index,=links,=follow-links]\n\
4443 Display the contents of DWARF debug sections\n"));
4444 fprintf (stream, _("\
4445 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4446 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4447 or deeper\n"));
4448#ifdef SUPPORT_DISASSEMBLY
4449 fprintf (stream, _("\
4450 -i --instruction-dump=<number|name>\n\
4451 Disassemble the contents of section <number|name>\n"));
4452#endif
4453 fprintf (stream, _("\
4454 -I --histogram Display histogram of bucket list lengths\n\
4455 -W --wide Allow output width to exceed 80 characters\n\
4456 @<file> Read options from <file>\n\
4457 -H --help Display this information\n\
4458 -v --version Display the version number of readelf\n"));
4459
4460 if (REPORT_BUGS_TO[0] && stream == stdout)
4461 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4462
4463 exit (stream == stdout ? 0 : 1);
4464}
4465
4466/* Record the fact that the user wants the contents of section number
4467 SECTION to be displayed using the method(s) encoded as flags bits
4468 in TYPE. Note, TYPE can be zero if we are creating the array for
4469 the first time. */
4470
4471static void
4472request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4473{
4474 if (section >= filedata->num_dump_sects)
4475 {
4476 dump_type * new_dump_sects;
4477
4478 new_dump_sects = (dump_type *) calloc (section + 1,
4479 sizeof (* new_dump_sects));
4480
4481 if (new_dump_sects == NULL)
4482 error (_("Out of memory allocating dump request table.\n"));
4483 else
4484 {
4485 if (filedata->dump_sects)
4486 {
4487 /* Copy current flag settings. */
4488 memcpy (new_dump_sects, filedata->dump_sects,
4489 filedata->num_dump_sects * sizeof (* new_dump_sects));
4490
4491 free (filedata->dump_sects);
4492 }
4493
4494 filedata->dump_sects = new_dump_sects;
4495 filedata->num_dump_sects = section + 1;
4496 }
4497 }
4498
4499 if (filedata->dump_sects)
4500 filedata->dump_sects[section] |= type;
4501}
4502
4503/* Request a dump by section name. */
4504
4505static void
4506request_dump_byname (const char * section, dump_type type)
4507{
4508 struct dump_list_entry * new_request;
4509
4510 new_request = (struct dump_list_entry *)
4511 malloc (sizeof (struct dump_list_entry));
4512 if (!new_request)
4513 error (_("Out of memory allocating dump request table.\n"));
4514
4515 new_request->name = strdup (section);
4516 if (!new_request->name)
4517 error (_("Out of memory allocating dump request table.\n"));
4518
4519 new_request->type = type;
4520
4521 new_request->next = dump_sects_byname;
4522 dump_sects_byname = new_request;
4523}
4524
4525static inline void
4526request_dump (Filedata * filedata, dump_type type)
4527{
4528 int section;
4529 char * cp;
4530
4531 do_dump++;
4532 section = strtoul (optarg, & cp, 0);
4533
4534 if (! *cp && section >= 0)
4535 request_dump_bynumber (filedata, section, type);
4536 else
4537 request_dump_byname (optarg, type);
4538}
4539
4540static void
4541parse_args (Filedata * filedata, int argc, char ** argv)
4542{
4543 int c;
4544
4545 if (argc < 2)
4546 usage (stderr);
4547
4548 while ((c = getopt_long
4549 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4550 {
4551 switch (c)
4552 {
4553 case 0:
4554 /* Long options. */
4555 break;
4556 case 'H':
4557 usage (stdout);
4558 break;
4559
4560 case 'a':
4561 do_syms = TRUE;
4562 do_reloc = TRUE;
4563 do_unwind = TRUE;
4564 do_dynamic = TRUE;
4565 do_header = TRUE;
4566 do_sections = TRUE;
4567 do_section_groups = TRUE;
4568 do_segments = TRUE;
4569 do_version = TRUE;
4570 do_histogram = TRUE;
4571 do_arch = TRUE;
4572 do_notes = TRUE;
4573 break;
4574 case 'g':
4575 do_section_groups = TRUE;
4576 break;
4577 case 't':
4578 case 'N':
4579 do_sections = TRUE;
4580 do_section_details = TRUE;
4581 break;
4582 case 'e':
4583 do_header = TRUE;
4584 do_sections = TRUE;
4585 do_segments = TRUE;
4586 break;
4587 case 'A':
4588 do_arch = TRUE;
4589 break;
4590 case 'D':
4591 do_using_dynamic = TRUE;
4592 break;
4593 case 'r':
4594 do_reloc = TRUE;
4595 break;
4596 case 'u':
4597 do_unwind = TRUE;
4598 break;
4599 case 'h':
4600 do_header = TRUE;
4601 break;
4602 case 'l':
4603 do_segments = TRUE;
4604 break;
4605 case 's':
4606 do_syms = TRUE;
4607 break;
4608 case 'S':
4609 do_sections = TRUE;
4610 break;
4611 case 'd':
4612 do_dynamic = TRUE;
4613 break;
4614 case 'I':
4615 do_histogram = TRUE;
4616 break;
4617 case 'n':
4618 do_notes = TRUE;
4619 break;
4620 case 'c':
4621 do_archive_index = TRUE;
4622 break;
4623 case 'x':
4624 request_dump (filedata, HEX_DUMP);
4625 break;
4626 case 'p':
4627 request_dump (filedata, STRING_DUMP);
4628 break;
4629 case 'R':
4630 request_dump (filedata, RELOC_DUMP);
4631 break;
4632 case 'z':
4633 decompress_dumps = TRUE;
4634 break;
4635 case 'w':
4636 do_dump = TRUE;
4637 if (optarg == 0)
4638 {
4639 do_debugging = TRUE;
4640 dwarf_select_sections_all ();
4641 }
4642 else
4643 {
4644 do_debugging = FALSE;
4645 dwarf_select_sections_by_letters (optarg);
4646 }
4647 break;
4648 case OPTION_DEBUG_DUMP:
4649 do_dump = TRUE;
4650 if (optarg == 0)
4651 do_debugging = TRUE;
4652 else
4653 {
4654 do_debugging = FALSE;
4655 dwarf_select_sections_by_names (optarg);
4656 }
4657 break;
4658 case OPTION_DWARF_DEPTH:
4659 {
4660 char *cp;
4661
4662 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4663 }
4664 break;
4665 case OPTION_DWARF_START:
4666 {
4667 char *cp;
4668
4669 dwarf_start_die = strtoul (optarg, & cp, 0);
4670 }
4671 break;
4672 case OPTION_DWARF_CHECK:
4673 dwarf_check = TRUE;
4674 break;
4675 case OPTION_DYN_SYMS:
4676 do_dyn_syms = TRUE;
4677 break;
4678#ifdef SUPPORT_DISASSEMBLY
4679 case 'i':
4680 request_dump (filedata, DISASS_DUMP);
4681 break;
4682#endif
4683 case 'v':
4684 print_version (program_name);
4685 break;
4686 case 'V':
4687 do_version = TRUE;
4688 break;
4689 case 'W':
4690 do_wide = TRUE;
4691 break;
4692 default:
4693 /* xgettext:c-format */
4694 error (_("Invalid option '-%c'\n"), c);
4695 /* Fall through. */
4696 case '?':
4697 usage (stderr);
4698 }
4699 }
4700
4701 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4702 && !do_segments && !do_header && !do_dump && !do_version
4703 && !do_histogram && !do_debugging && !do_arch && !do_notes
4704 && !do_section_groups && !do_archive_index
4705 && !do_dyn_syms)
4706 usage (stderr);
4707}
4708
4709static const char *
4710get_elf_class (unsigned int elf_class)
4711{
4712 static char buff[32];
4713
4714 switch (elf_class)
4715 {
4716 case ELFCLASSNONE: return _("none");
4717 case ELFCLASS32: return "ELF32";
4718 case ELFCLASS64: return "ELF64";
4719 default:
4720 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4721 return buff;
4722 }
4723}
4724
4725static const char *
4726get_data_encoding (unsigned int encoding)
4727{
4728 static char buff[32];
4729
4730 switch (encoding)
4731 {
4732 case ELFDATANONE: return _("none");
4733 case ELFDATA2LSB: return _("2's complement, little endian");
4734 case ELFDATA2MSB: return _("2's complement, big endian");
4735 default:
4736 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4737 return buff;
4738 }
4739}
4740
4741/* Decode the data held in 'filedata->file_header'. */
4742
4743static bfd_boolean
4744process_file_header (Filedata * filedata)
4745{
4746 Elf_Internal_Ehdr * header = & filedata->file_header;
4747
4748 if ( header->e_ident[EI_MAG0] != ELFMAG0
4749 || header->e_ident[EI_MAG1] != ELFMAG1
4750 || header->e_ident[EI_MAG2] != ELFMAG2
4751 || header->e_ident[EI_MAG3] != ELFMAG3)
4752 {
4753 error
4754 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4755 return FALSE;
4756 }
4757
4758 init_dwarf_regnames (header->e_machine);
4759
4760 if (do_header)
4761 {
4762 unsigned i;
4763
4764 printf (_("ELF Header:\n"));
4765 printf (_(" Magic: "));
4766 for (i = 0; i < EI_NIDENT; i++)
4767 printf ("%2.2x ", header->e_ident[i]);
4768 printf ("\n");
4769 printf (_(" Class: %s\n"),
4770 get_elf_class (header->e_ident[EI_CLASS]));
4771 printf (_(" Data: %s\n"),
4772 get_data_encoding (header->e_ident[EI_DATA]));
4773 printf (_(" Version: %d%s\n"),
4774 header->e_ident[EI_VERSION],
4775 (header->e_ident[EI_VERSION] == EV_CURRENT
4776 ? _(" (current)")
4777 : (header->e_ident[EI_VERSION] != EV_NONE
4778 ? _(" <unknown>")
4779 : "")));
4780 printf (_(" OS/ABI: %s\n"),
4781 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4782 printf (_(" ABI Version: %d\n"),
4783 header->e_ident[EI_ABIVERSION]);
4784 printf (_(" Type: %s\n"),
4785 get_file_type (header->e_type));
4786 printf (_(" Machine: %s\n"),
4787 get_machine_name (header->e_machine));
4788 printf (_(" Version: 0x%lx\n"),
4789 header->e_version);
4790
4791 printf (_(" Entry point address: "));
4792 print_vma (header->e_entry, PREFIX_HEX);
4793 printf (_("\n Start of program headers: "));
4794 print_vma (header->e_phoff, DEC);
4795 printf (_(" (bytes into file)\n Start of section headers: "));
4796 print_vma (header->e_shoff, DEC);
4797 printf (_(" (bytes into file)\n"));
4798
4799 printf (_(" Flags: 0x%lx%s\n"),
4800 header->e_flags,
4801 get_machine_flags (filedata, header->e_flags, header->e_machine));
4802 printf (_(" Size of this header: %u (bytes)\n"),
4803 header->e_ehsize);
4804 printf (_(" Size of program headers: %u (bytes)\n"),
4805 header->e_phentsize);
4806 printf (_(" Number of program headers: %u"),
4807 header->e_phnum);
4808 if (filedata->section_headers != NULL
4809 && header->e_phnum == PN_XNUM
4810 && filedata->section_headers[0].sh_info != 0)
4811 {
4812 header->e_phnum = filedata->section_headers[0].sh_info;
4813 printf (" (%u)", header->e_phnum);
4814 }
4815 putc ('\n', stdout);
4816 printf (_(" Size of section headers: %u (bytes)\n"),
4817 header->e_shentsize);
4818 printf (_(" Number of section headers: %u"),
4819 header->e_shnum);
4820 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4821 {
4822 header->e_shnum = filedata->section_headers[0].sh_size;
4823 printf (" (%u)", header->e_shnum);
4824 }
4825 putc ('\n', stdout);
4826 printf (_(" Section header string table index: %u"),
4827 header->e_shstrndx);
4828 if (filedata->section_headers != NULL
4829 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4830 {
4831 header->e_shstrndx = filedata->section_headers[0].sh_link;
4832 printf (" (%u)", header->e_shstrndx);
4833 }
4834 if (header->e_shstrndx != SHN_UNDEF
4835 && header->e_shstrndx >= header->e_shnum)
4836 {
4837 header->e_shstrndx = SHN_UNDEF;
4838 printf (_(" <corrupt: out of range>"));
4839 }
4840 putc ('\n', stdout);
4841 }
4842
4843 if (filedata->section_headers != NULL)
4844 {
4845 if (header->e_phnum == PN_XNUM
4846 && filedata->section_headers[0].sh_info != 0)
4847 header->e_phnum = filedata->section_headers[0].sh_info;
4848 if (header->e_shnum == SHN_UNDEF)
4849 header->e_shnum = filedata->section_headers[0].sh_size;
4850 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4851 header->e_shstrndx = filedata->section_headers[0].sh_link;
4852 if (header->e_shstrndx >= header->e_shnum)
4853 header->e_shstrndx = SHN_UNDEF;
4854 free (filedata->section_headers);
4855 filedata->section_headers = NULL;
4856 }
4857
4858 return TRUE;
4859}
4860
4861/* Read in the program headers from FILEDATA and store them in PHEADERS.
4862 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4863
4864static bfd_boolean
4865get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4866{
4867 Elf32_External_Phdr * phdrs;
4868 Elf32_External_Phdr * external;
4869 Elf_Internal_Phdr * internal;
4870 unsigned int i;
4871 unsigned int size = filedata->file_header.e_phentsize;
4872 unsigned int num = filedata->file_header.e_phnum;
4873
4874 /* PR binutils/17531: Cope with unexpected section header sizes. */
4875 if (size == 0 || num == 0)
4876 return FALSE;
4877 if (size < sizeof * phdrs)
4878 {
4879 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4880 return FALSE;
4881 }
4882 if (size > sizeof * phdrs)
4883 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4884
4885 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4886 size, num, _("program headers"));
4887 if (phdrs == NULL)
4888 return FALSE;
4889
4890 for (i = 0, internal = pheaders, external = phdrs;
4891 i < filedata->file_header.e_phnum;
4892 i++, internal++, external++)
4893 {
4894 internal->p_type = BYTE_GET (external->p_type);
4895 internal->p_offset = BYTE_GET (external->p_offset);
4896 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4897 internal->p_paddr = BYTE_GET (external->p_paddr);
4898 internal->p_filesz = BYTE_GET (external->p_filesz);
4899 internal->p_memsz = BYTE_GET (external->p_memsz);
4900 internal->p_flags = BYTE_GET (external->p_flags);
4901 internal->p_align = BYTE_GET (external->p_align);
4902 }
4903
4904 free (phdrs);
4905 return TRUE;
4906}
4907
4908/* Read in the program headers from FILEDATA and store them in PHEADERS.
4909 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4910
4911static bfd_boolean
4912get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4913{
4914 Elf64_External_Phdr * phdrs;
4915 Elf64_External_Phdr * external;
4916 Elf_Internal_Phdr * internal;
4917 unsigned int i;
4918 unsigned int size = filedata->file_header.e_phentsize;
4919 unsigned int num = filedata->file_header.e_phnum;
4920
4921 /* PR binutils/17531: Cope with unexpected section header sizes. */
4922 if (size == 0 || num == 0)
4923 return FALSE;
4924 if (size < sizeof * phdrs)
4925 {
4926 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4927 return FALSE;
4928 }
4929 if (size > sizeof * phdrs)
4930 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4931
4932 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4933 size, num, _("program headers"));
4934 if (!phdrs)
4935 return FALSE;
4936
4937 for (i = 0, internal = pheaders, external = phdrs;
4938 i < filedata->file_header.e_phnum;
4939 i++, internal++, external++)
4940 {
4941 internal->p_type = BYTE_GET (external->p_type);
4942 internal->p_flags = BYTE_GET (external->p_flags);
4943 internal->p_offset = BYTE_GET (external->p_offset);
4944 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4945 internal->p_paddr = BYTE_GET (external->p_paddr);
4946 internal->p_filesz = BYTE_GET (external->p_filesz);
4947 internal->p_memsz = BYTE_GET (external->p_memsz);
4948 internal->p_align = BYTE_GET (external->p_align);
4949 }
4950
4951 free (phdrs);
4952 return TRUE;
4953}
4954
4955/* Returns TRUE if the program headers were read into `program_headers'. */
4956
4957static bfd_boolean
4958get_program_headers (Filedata * filedata)
4959{
4960 Elf_Internal_Phdr * phdrs;
4961
4962 /* Check cache of prior read. */
4963 if (filedata->program_headers != NULL)
4964 return TRUE;
4965
4966 /* Be kind to memory checkers by looking for
4967 e_phnum values which we know must be invalid. */
4968 if (filedata->file_header.e_phnum
4969 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4970 >= filedata->file_size)
4971 {
4972 error (_("Too many program headers - %#x - the file is not that big\n"),
4973 filedata->file_header.e_phnum);
4974 return FALSE;
4975 }
4976
4977 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4978 sizeof (Elf_Internal_Phdr));
4979 if (phdrs == NULL)
4980 {
4981 error (_("Out of memory reading %u program headers\n"),
4982 filedata->file_header.e_phnum);
4983 return FALSE;
4984 }
4985
4986 if (is_32bit_elf
4987 ? get_32bit_program_headers (filedata, phdrs)
4988 : get_64bit_program_headers (filedata, phdrs))
4989 {
4990 filedata->program_headers = phdrs;
4991 return TRUE;
4992 }
4993
4994 free (phdrs);
4995 return FALSE;
4996}
4997
4998/* Returns TRUE if the program headers were loaded. */
4999
5000static bfd_boolean
5001process_program_headers (Filedata * filedata)
5002{
5003 Elf_Internal_Phdr * segment;
5004 unsigned int i;
5005 Elf_Internal_Phdr * previous_load = NULL;
5006
5007 if (filedata->file_header.e_phnum == 0)
5008 {
5009 /* PR binutils/12467. */
5010 if (filedata->file_header.e_phoff != 0)
5011 {
5012 warn (_("possibly corrupt ELF header - it has a non-zero program"
5013 " header offset, but no program headers\n"));
5014 return FALSE;
5015 }
5016 else if (do_segments)
5017 printf (_("\nThere are no program headers in this file.\n"));
5018 return TRUE;
5019 }
5020
5021 if (do_segments && !do_header)
5022 {
5023 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5024 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5025 printf (ngettext ("There is %d program header, starting at offset %s\n",
5026 "There are %d program headers, starting at offset %s\n",
5027 filedata->file_header.e_phnum),
5028 filedata->file_header.e_phnum,
5029 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5030 }
5031
5032 if (! get_program_headers (filedata))
5033 return TRUE;
5034
5035 if (do_segments)
5036 {
5037 if (filedata->file_header.e_phnum > 1)
5038 printf (_("\nProgram Headers:\n"));
5039 else
5040 printf (_("\nProgram Headers:\n"));
5041
5042 if (is_32bit_elf)
5043 printf
5044 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5045 else if (do_wide)
5046 printf
5047 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5048 else
5049 {
5050 printf
5051 (_(" Type Offset VirtAddr PhysAddr\n"));
5052 printf
5053 (_(" FileSiz MemSiz Flags Align\n"));
5054 }
5055 }
5056
5057 dynamic_addr = 0;
5058 dynamic_size = 0;
5059
5060 for (i = 0, segment = filedata->program_headers;
5061 i < filedata->file_header.e_phnum;
5062 i++, segment++)
5063 {
5064 if (do_segments)
5065 {
5066 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5067
5068 if (is_32bit_elf)
5069 {
5070 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5071 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5072 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5073 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5074 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5075 printf ("%c%c%c ",
5076 (segment->p_flags & PF_R ? 'R' : ' '),
5077 (segment->p_flags & PF_W ? 'W' : ' '),
5078 (segment->p_flags & PF_X ? 'E' : ' '));
5079 printf ("%#lx", (unsigned long) segment->p_align);
5080 }
5081 else if (do_wide)
5082 {
5083 if ((unsigned long) segment->p_offset == segment->p_offset)
5084 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5085 else
5086 {
5087 print_vma (segment->p_offset, FULL_HEX);
5088 putchar (' ');
5089 }
5090
5091 print_vma (segment->p_vaddr, FULL_HEX);
5092 putchar (' ');
5093 print_vma (segment->p_paddr, FULL_HEX);
5094 putchar (' ');
5095
5096 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5097 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5098 else
5099 {
5100 print_vma (segment->p_filesz, FULL_HEX);
5101 putchar (' ');
5102 }
5103
5104 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5105 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5106 else
5107 {
5108 print_vma (segment->p_memsz, FULL_HEX);
5109 }
5110
5111 printf (" %c%c%c ",
5112 (segment->p_flags & PF_R ? 'R' : ' '),
5113 (segment->p_flags & PF_W ? 'W' : ' '),
5114 (segment->p_flags & PF_X ? 'E' : ' '));
5115
5116 if ((unsigned long) segment->p_align == segment->p_align)
5117 printf ("%#lx", (unsigned long) segment->p_align);
5118 else
5119 {
5120 print_vma (segment->p_align, PREFIX_HEX);
5121 }
5122 }
5123 else
5124 {
5125 print_vma (segment->p_offset, FULL_HEX);
5126 putchar (' ');
5127 print_vma (segment->p_vaddr, FULL_HEX);
5128 putchar (' ');
5129 print_vma (segment->p_paddr, FULL_HEX);
5130 printf ("\n ");
5131 print_vma (segment->p_filesz, FULL_HEX);
5132 putchar (' ');
5133 print_vma (segment->p_memsz, FULL_HEX);
5134 printf (" %c%c%c ",
5135 (segment->p_flags & PF_R ? 'R' : ' '),
5136 (segment->p_flags & PF_W ? 'W' : ' '),
5137 (segment->p_flags & PF_X ? 'E' : ' '));
5138 print_vma (segment->p_align, PREFIX_HEX);
5139 }
5140
5141 putc ('\n', stdout);
5142 }
5143
5144 switch (segment->p_type)
5145 {
5146 case PT_LOAD:
5147#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5148 required by the ELF standard, several programs, including the Linux
5149 kernel, make use of non-ordered segments. */
5150 if (previous_load
5151 && previous_load->p_vaddr > segment->p_vaddr)
5152 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5153#endif
5154 if (segment->p_memsz < segment->p_filesz)
5155 error (_("the segment's file size is larger than its memory size\n"));
5156 previous_load = segment;
5157 break;
5158
5159 case PT_PHDR:
5160 /* PR 20815 - Verify that the program header is loaded into memory. */
5161 if (i > 0 && previous_load != NULL)
5162 error (_("the PHDR segment must occur before any LOAD segment\n"));
5163 if (filedata->file_header.e_machine != EM_PARISC)
5164 {
5165 unsigned int j;
5166
5167 for (j = 1; j < filedata->file_header.e_phnum; j++)
5168 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5169 && (filedata->program_headers[j].p_vaddr
5170 + filedata->program_headers[j].p_memsz)
5171 >= (segment->p_vaddr + segment->p_filesz))
5172 break;
5173 if (j == filedata->file_header.e_phnum)
5174 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5175 }
5176 break;
5177
5178 case PT_DYNAMIC:
5179 if (dynamic_addr)
5180 error (_("more than one dynamic segment\n"));
5181
5182 /* By default, assume that the .dynamic section is the first
5183 section in the DYNAMIC segment. */
5184 dynamic_addr = segment->p_offset;
5185 dynamic_size = segment->p_filesz;
5186
5187 /* Try to locate the .dynamic section. If there is
5188 a section header table, we can easily locate it. */
5189 if (filedata->section_headers != NULL)
5190 {
5191 Elf_Internal_Shdr * sec;
5192
5193 sec = find_section (filedata, ".dynamic");
5194 if (sec == NULL || sec->sh_size == 0)
5195 {
5196 /* A corresponding .dynamic section is expected, but on
5197 IA-64/OpenVMS it is OK for it to be missing. */
5198 if (!is_ia64_vms (filedata))
5199 error (_("no .dynamic section in the dynamic segment\n"));
5200 break;
5201 }
5202
5203 if (sec->sh_type == SHT_NOBITS)
5204 {
5205 dynamic_size = 0;
5206 break;
5207 }
5208
5209 dynamic_addr = sec->sh_offset;
5210 dynamic_size = sec->sh_size;
5211
5212 if (dynamic_addr < segment->p_offset
5213 || dynamic_addr > segment->p_offset + segment->p_filesz)
5214 warn (_("the .dynamic section is not contained"
5215 " within the dynamic segment\n"));
5216 else if (dynamic_addr > segment->p_offset)
5217 warn (_("the .dynamic section is not the first section"
5218 " in the dynamic segment.\n"));
5219 }
5220
5221 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5222 segment. Check this after matching against the section headers
5223 so we don't warn on debuginfo file (which have NOBITS .dynamic
5224 sections). */
5225 if (dynamic_addr + dynamic_size >= filedata->file_size)
5226 {
5227 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5228 dynamic_addr = dynamic_size = 0;
5229 }
5230 break;
5231
5232 case PT_INTERP:
5233 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5234 SEEK_SET))
5235 error (_("Unable to find program interpreter name\n"));
5236 else
5237 {
5238 char fmt [32];
5239 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5240
5241 if (ret >= (int) sizeof (fmt) || ret < 0)
5242 error (_("Internal error: failed to create format string to display program interpreter\n"));
5243
5244 program_interpreter[0] = 0;
5245 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5246 error (_("Unable to read program interpreter name\n"));
5247
5248 if (do_segments)
5249 printf (_(" [Requesting program interpreter: %s]\n"),
5250 program_interpreter);
5251 }
5252 break;
5253 }
5254 }
5255
5256 if (do_segments
5257 && filedata->section_headers != NULL
5258 && filedata->string_table != NULL)
5259 {
5260 printf (_("\n Section to Segment mapping:\n"));
5261 printf (_(" Segment Sections...\n"));
5262
5263 for (i = 0; i < filedata->file_header.e_phnum; i++)
5264 {
5265 unsigned int j;
5266 Elf_Internal_Shdr * section;
5267
5268 segment = filedata->program_headers + i;
5269 section = filedata->section_headers + 1;
5270
5271 printf (" %2.2d ", i);
5272
5273 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5274 {
5275 if (!ELF_TBSS_SPECIAL (section, segment)
5276 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5277 printf ("%s ", printable_section_name (filedata, section));
5278 }
5279
5280 putc ('\n',stdout);
5281 }
5282 }
5283
5284 return TRUE;
5285}
5286
5287
5288/* Find the file offset corresponding to VMA by using the program headers. */
5289
5290static long
5291offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5292{
5293 Elf_Internal_Phdr * seg;
5294
5295 if (! get_program_headers (filedata))
5296 {
5297 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5298 return (long) vma;
5299 }
5300
5301 for (seg = filedata->program_headers;
5302 seg < filedata->program_headers + filedata->file_header.e_phnum;
5303 ++seg)
5304 {
5305 if (seg->p_type != PT_LOAD)
5306 continue;
5307
5308 if (vma >= (seg->p_vaddr & -seg->p_align)
5309 && vma + size <= seg->p_vaddr + seg->p_filesz)
5310 return vma - seg->p_vaddr + seg->p_offset;
5311 }
5312
5313 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5314 (unsigned long) vma);
5315 return (long) vma;
5316}
5317
5318
5319/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5320 If PROBE is true, this is just a probe and we do not generate any error
5321 messages if the load fails. */
5322
5323static bfd_boolean
5324get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5325{
5326 Elf32_External_Shdr * shdrs;
5327 Elf_Internal_Shdr * internal;
5328 unsigned int i;
5329 unsigned int size = filedata->file_header.e_shentsize;
5330 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5331
5332 /* PR binutils/17531: Cope with unexpected section header sizes. */
5333 if (size == 0 || num == 0)
5334 return FALSE;
5335 if (size < sizeof * shdrs)
5336 {
5337 if (! probe)
5338 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5339 return FALSE;
5340 }
5341 if (!probe && size > sizeof * shdrs)
5342 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5343
5344 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5345 size, num,
5346 probe ? NULL : _("section headers"));
5347 if (shdrs == NULL)
5348 return FALSE;
5349
5350 free (filedata->section_headers);
5351 filedata->section_headers = (Elf_Internal_Shdr *)
5352 cmalloc (num, sizeof (Elf_Internal_Shdr));
5353 if (filedata->section_headers == NULL)
5354 {
5355 if (!probe)
5356 error (_("Out of memory reading %u section headers\n"), num);
5357 free (shdrs);
5358 return FALSE;
5359 }
5360
5361 for (i = 0, internal = filedata->section_headers;
5362 i < num;
5363 i++, internal++)
5364 {
5365 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5366 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5367 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5368 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5369 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5370 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5371 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5372 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5373 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5374 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5375 if (!probe && internal->sh_link > num)
5376 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5377 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5378 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5379 }
5380
5381 free (shdrs);
5382 return TRUE;
5383}
5384
5385/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5386
5387static bfd_boolean
5388get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5389{
5390 Elf64_External_Shdr * shdrs;
5391 Elf_Internal_Shdr * internal;
5392 unsigned int i;
5393 unsigned int size = filedata->file_header.e_shentsize;
5394 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5395
5396 /* PR binutils/17531: Cope with unexpected section header sizes. */
5397 if (size == 0 || num == 0)
5398 return FALSE;
5399
5400 if (size < sizeof * shdrs)
5401 {
5402 if (! probe)
5403 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5404 return FALSE;
5405 }
5406
5407 if (! probe && size > sizeof * shdrs)
5408 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5409
5410 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5411 filedata->file_header.e_shoff,
5412 size, num,
5413 probe ? NULL : _("section headers"));
5414 if (shdrs == NULL)
5415 return FALSE;
5416
5417 free (filedata->section_headers);
5418 filedata->section_headers = (Elf_Internal_Shdr *)
5419 cmalloc (num, sizeof (Elf_Internal_Shdr));
5420 if (filedata->section_headers == NULL)
5421 {
5422 if (! probe)
5423 error (_("Out of memory reading %u section headers\n"), num);
5424 free (shdrs);
5425 return FALSE;
5426 }
5427
5428 for (i = 0, internal = filedata->section_headers;
5429 i < num;
5430 i++, internal++)
5431 {
5432 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5433 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5434 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5435 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5436 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5437 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5438 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5439 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5440 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5441 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5442 if (!probe && internal->sh_link > num)
5443 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5444 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5445 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5446 }
5447
5448 free (shdrs);
5449 return TRUE;
5450}
5451
5452static Elf_Internal_Sym *
5453get_32bit_elf_symbols (Filedata * filedata,
5454 Elf_Internal_Shdr * section,
5455 unsigned long * num_syms_return)
5456{
5457 unsigned long number = 0;
5458 Elf32_External_Sym * esyms = NULL;
5459 Elf_External_Sym_Shndx * shndx = NULL;
5460 Elf_Internal_Sym * isyms = NULL;
5461 Elf_Internal_Sym * psym;
5462 unsigned int j;
5463 elf_section_list * entry;
5464
5465 if (section->sh_size == 0)
5466 {
5467 if (num_syms_return != NULL)
5468 * num_syms_return = 0;
5469 return NULL;
5470 }
5471
5472 /* Run some sanity checks first. */
5473 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5474 {
5475 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5476 printable_section_name (filedata, section),
5477 (unsigned long) section->sh_entsize);
5478 goto exit_point;
5479 }
5480
5481 if (section->sh_size > filedata->file_size)
5482 {
5483 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5484 printable_section_name (filedata, section),
5485 (unsigned long) section->sh_size);
5486 goto exit_point;
5487 }
5488
5489 number = section->sh_size / section->sh_entsize;
5490
5491 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5492 {
5493 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5494 (unsigned long) section->sh_size,
5495 printable_section_name (filedata, section),
5496 (unsigned long) section->sh_entsize);
5497 goto exit_point;
5498 }
5499
5500 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5501 section->sh_size, _("symbols"));
5502 if (esyms == NULL)
5503 goto exit_point;
5504
5505 shndx = NULL;
5506 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5507 {
5508 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5509 continue;
5510
5511 if (shndx != NULL)
5512 {
5513 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5514 free (shndx);
5515 }
5516
5517 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5518 entry->hdr->sh_offset,
5519 1, entry->hdr->sh_size,
5520 _("symbol table section indices"));
5521 if (shndx == NULL)
5522 goto exit_point;
5523
5524 /* PR17531: file: heap-buffer-overflow */
5525 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5526 {
5527 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5528 printable_section_name (filedata, entry->hdr),
5529 (unsigned long) entry->hdr->sh_size,
5530 (unsigned long) section->sh_size);
5531 goto exit_point;
5532 }
5533 }
5534
5535 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5536
5537 if (isyms == NULL)
5538 {
5539 error (_("Out of memory reading %lu symbols\n"),
5540 (unsigned long) number);
5541 goto exit_point;
5542 }
5543
5544 for (j = 0, psym = isyms; j < number; j++, psym++)
5545 {
5546 psym->st_name = BYTE_GET (esyms[j].st_name);
5547 psym->st_value = BYTE_GET (esyms[j].st_value);
5548 psym->st_size = BYTE_GET (esyms[j].st_size);
5549 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5550 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5551 psym->st_shndx
5552 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5553 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5554 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5555 psym->st_info = BYTE_GET (esyms[j].st_info);
5556 psym->st_other = BYTE_GET (esyms[j].st_other);
5557 }
5558
5559 exit_point:
5560 free (shndx);
5561 free (esyms);
5562
5563 if (num_syms_return != NULL)
5564 * num_syms_return = isyms == NULL ? 0 : number;
5565
5566 return isyms;
5567}
5568
5569static Elf_Internal_Sym *
5570get_64bit_elf_symbols (Filedata * filedata,
5571 Elf_Internal_Shdr * section,
5572 unsigned long * num_syms_return)
5573{
5574 unsigned long number = 0;
5575 Elf64_External_Sym * esyms = NULL;
5576 Elf_External_Sym_Shndx * shndx = NULL;
5577 Elf_Internal_Sym * isyms = NULL;
5578 Elf_Internal_Sym * psym;
5579 unsigned int j;
5580 elf_section_list * entry;
5581
5582 if (section->sh_size == 0)
5583 {
5584 if (num_syms_return != NULL)
5585 * num_syms_return = 0;
5586 return NULL;
5587 }
5588
5589 /* Run some sanity checks first. */
5590 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5591 {
5592 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5593 printable_section_name (filedata, section),
5594 (unsigned long) section->sh_entsize);
5595 goto exit_point;
5596 }
5597
5598 if (section->sh_size > filedata->file_size)
5599 {
5600 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5601 printable_section_name (filedata, section),
5602 (unsigned long) section->sh_size);
5603 goto exit_point;
5604 }
5605
5606 number = section->sh_size / section->sh_entsize;
5607
5608 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5609 {
5610 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5611 (unsigned long) section->sh_size,
5612 printable_section_name (filedata, section),
5613 (unsigned long) section->sh_entsize);
5614 goto exit_point;
5615 }
5616
5617 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5618 section->sh_size, _("symbols"));
5619 if (!esyms)
5620 goto exit_point;
5621
5622 shndx = NULL;
5623 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5624 {
5625 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5626 continue;
5627
5628 if (shndx != NULL)
5629 {
5630 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5631 free (shndx);
5632 }
5633
5634 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5635 entry->hdr->sh_offset,
5636 1, entry->hdr->sh_size,
5637 _("symbol table section indices"));
5638 if (shndx == NULL)
5639 goto exit_point;
5640
5641 /* PR17531: file: heap-buffer-overflow */
5642 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5643 {
5644 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5645 printable_section_name (filedata, entry->hdr),
5646 (unsigned long) entry->hdr->sh_size,
5647 (unsigned long) section->sh_size);
5648 goto exit_point;
5649 }
5650 }
5651
5652 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5653
5654 if (isyms == NULL)
5655 {
5656 error (_("Out of memory reading %lu symbols\n"),
5657 (unsigned long) number);
5658 goto exit_point;
5659 }
5660
5661 for (j = 0, psym = isyms; j < number; j++, psym++)
5662 {
5663 psym->st_name = BYTE_GET (esyms[j].st_name);
5664 psym->st_info = BYTE_GET (esyms[j].st_info);
5665 psym->st_other = BYTE_GET (esyms[j].st_other);
5666 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5667
5668 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5669 psym->st_shndx
5670 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5671 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5672 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5673
5674 psym->st_value = BYTE_GET (esyms[j].st_value);
5675 psym->st_size = BYTE_GET (esyms[j].st_size);
5676 }
5677
5678 exit_point:
5679 free (shndx);
5680 free (esyms);
5681
5682 if (num_syms_return != NULL)
5683 * num_syms_return = isyms == NULL ? 0 : number;
5684
5685 return isyms;
5686}
5687
5688static const char *
5689get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5690{
5691 static char buff[1024];
5692 char * p = buff;
5693 unsigned int field_size = is_32bit_elf ? 8 : 16;
5694 signed int sindex;
5695 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5696 bfd_vma os_flags = 0;
5697 bfd_vma proc_flags = 0;
5698 bfd_vma unknown_flags = 0;
5699 static const struct
5700 {
5701 const char * str;
5702 unsigned int len;
5703 }
5704 flags [] =
5705 {
5706 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5707 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5708 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5709 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5710 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5711 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5712 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5713 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5714 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5715 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5716 /* IA-64 specific. */
5717 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5718 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5719 /* IA-64 OpenVMS specific. */
5720 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5721 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5722 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5723 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5724 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5725 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5726 /* Generic. */
5727 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5728 /* SPARC specific. */
5729 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5730 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5731 /* ARM specific. */
5732 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5733 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5734 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5735 /* GNU specific. */
5736 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5737 /* VLE specific. */
5738 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5739 };
5740
5741 if (do_section_details)
5742 {
5743 sprintf (buff, "[%*.*lx]: ",
5744 field_size, field_size, (unsigned long) sh_flags);
5745 p += field_size + 4;
5746 }
5747
5748 while (sh_flags)
5749 {
5750 bfd_vma flag;
5751
5752 flag = sh_flags & - sh_flags;
5753 sh_flags &= ~ flag;
5754
5755 if (do_section_details)
5756 {
5757 switch (flag)
5758 {
5759 case SHF_WRITE: sindex = 0; break;
5760 case SHF_ALLOC: sindex = 1; break;
5761 case SHF_EXECINSTR: sindex = 2; break;
5762 case SHF_MERGE: sindex = 3; break;
5763 case SHF_STRINGS: sindex = 4; break;
5764 case SHF_INFO_LINK: sindex = 5; break;
5765 case SHF_LINK_ORDER: sindex = 6; break;
5766 case SHF_OS_NONCONFORMING: sindex = 7; break;
5767 case SHF_GROUP: sindex = 8; break;
5768 case SHF_TLS: sindex = 9; break;
5769 case SHF_EXCLUDE: sindex = 18; break;
5770 case SHF_COMPRESSED: sindex = 20; break;
5771 case SHF_GNU_MBIND: sindex = 24; break;
5772
5773 default:
5774 sindex = -1;
5775 switch (filedata->file_header.e_machine)
5776 {
5777 case EM_IA_64:
5778 if (flag == SHF_IA_64_SHORT)
5779 sindex = 10;
5780 else if (flag == SHF_IA_64_NORECOV)
5781 sindex = 11;
5782#ifdef BFD64
5783 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5784 switch (flag)
5785 {
5786 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5787 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5788 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5789 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5790 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5791 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5792 default: break;
5793 }
5794#endif
5795 break;
5796
5797 case EM_386:
5798 case EM_IAMCU:
5799 case EM_X86_64:
5800 case EM_L1OM:
5801 case EM_K1OM:
5802 case EM_OLD_SPARCV9:
5803 case EM_SPARC32PLUS:
5804 case EM_SPARCV9:
5805 case EM_SPARC:
5806 if (flag == SHF_ORDERED)
5807 sindex = 19;
5808 break;
5809
5810 case EM_ARM:
5811 switch (flag)
5812 {
5813 case SHF_ENTRYSECT: sindex = 21; break;
5814 case SHF_ARM_PURECODE: sindex = 22; break;
5815 case SHF_COMDEF: sindex = 23; break;
5816 default: break;
5817 }
5818 break;
5819 case EM_PPC:
5820 if (flag == SHF_PPC_VLE)
5821 sindex = 25;
5822 break;
5823
5824 default:
5825 break;
5826 }
5827 }
5828
5829 if (sindex != -1)
5830 {
5831 if (p != buff + field_size + 4)
5832 {
5833 if (size < (10 + 2))
5834 {
5835 warn (_("Internal error: not enough buffer room for section flag info"));
5836 return _("<unknown>");
5837 }
5838 size -= 2;
5839 *p++ = ',';
5840 *p++ = ' ';
5841 }
5842
5843 size -= flags [sindex].len;
5844 p = stpcpy (p, flags [sindex].str);
5845 }
5846 else if (flag & SHF_MASKOS)
5847 os_flags |= flag;
5848 else if (flag & SHF_MASKPROC)
5849 proc_flags |= flag;
5850 else
5851 unknown_flags |= flag;
5852 }
5853 else
5854 {
5855 switch (flag)
5856 {
5857 case SHF_WRITE: *p = 'W'; break;
5858 case SHF_ALLOC: *p = 'A'; break;
5859 case SHF_EXECINSTR: *p = 'X'; break;
5860 case SHF_MERGE: *p = 'M'; break;
5861 case SHF_STRINGS: *p = 'S'; break;
5862 case SHF_INFO_LINK: *p = 'I'; break;
5863 case SHF_LINK_ORDER: *p = 'L'; break;
5864 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5865 case SHF_GROUP: *p = 'G'; break;
5866 case SHF_TLS: *p = 'T'; break;
5867 case SHF_EXCLUDE: *p = 'E'; break;
5868 case SHF_COMPRESSED: *p = 'C'; break;
5869 case SHF_GNU_MBIND: *p = 'D'; break;
5870
5871 default:
5872 if ((filedata->file_header.e_machine == EM_X86_64
5873 || filedata->file_header.e_machine == EM_L1OM
5874 || filedata->file_header.e_machine == EM_K1OM)
5875 && flag == SHF_X86_64_LARGE)
5876 *p = 'l';
5877 else if (filedata->file_header.e_machine == EM_ARM
5878 && flag == SHF_ARM_PURECODE)
5879 *p = 'y';
5880 else if (filedata->file_header.e_machine == EM_PPC
5881 && flag == SHF_PPC_VLE)
5882 *p = 'v';
5883 else if (flag & SHF_MASKOS)
5884 {
5885 *p = 'o';
5886 sh_flags &= ~ SHF_MASKOS;
5887 }
5888 else if (flag & SHF_MASKPROC)
5889 {
5890 *p = 'p';
5891 sh_flags &= ~ SHF_MASKPROC;
5892 }
5893 else
5894 *p = 'x';
5895 break;
5896 }
5897 p++;
5898 }
5899 }
5900
5901 if (do_section_details)
5902 {
5903 if (os_flags)
5904 {
5905 size -= 5 + field_size;
5906 if (p != buff + field_size + 4)
5907 {
5908 if (size < (2 + 1))
5909 {
5910 warn (_("Internal error: not enough buffer room for section flag info"));
5911 return _("<unknown>");
5912 }
5913 size -= 2;
5914 *p++ = ',';
5915 *p++ = ' ';
5916 }
5917 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5918 (unsigned long) os_flags);
5919 p += 5 + field_size;
5920 }
5921 if (proc_flags)
5922 {
5923 size -= 7 + field_size;
5924 if (p != buff + field_size + 4)
5925 {
5926 if (size < (2 + 1))
5927 {
5928 warn (_("Internal error: not enough buffer room for section flag info"));
5929 return _("<unknown>");
5930 }
5931 size -= 2;
5932 *p++ = ',';
5933 *p++ = ' ';
5934 }
5935 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5936 (unsigned long) proc_flags);
5937 p += 7 + field_size;
5938 }
5939 if (unknown_flags)
5940 {
5941 size -= 10 + field_size;
5942 if (p != buff + field_size + 4)
5943 {
5944 if (size < (2 + 1))
5945 {
5946 warn (_("Internal error: not enough buffer room for section flag info"));
5947 return _("<unknown>");
5948 }
5949 size -= 2;
5950 *p++ = ',';
5951 *p++ = ' ';
5952 }
5953 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5954 (unsigned long) unknown_flags);
5955 p += 10 + field_size;
5956 }
5957 }
5958
5959 *p = '\0';
5960 return buff;
5961}
5962
5963static unsigned int
5964get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5965{
5966 if (is_32bit_elf)
5967 {
5968 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5969
5970 if (size < sizeof (* echdr))
5971 {
5972 error (_("Compressed section is too small even for a compression header\n"));
5973 return 0;
5974 }
5975
5976 chdr->ch_type = BYTE_GET (echdr->ch_type);
5977 chdr->ch_size = BYTE_GET (echdr->ch_size);
5978 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5979 return sizeof (*echdr);
5980 }
5981 else
5982 {
5983 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5984
5985 if (size < sizeof (* echdr))
5986 {
5987 error (_("Compressed section is too small even for a compression header\n"));
5988 return 0;
5989 }
5990
5991 chdr->ch_type = BYTE_GET (echdr->ch_type);
5992 chdr->ch_size = BYTE_GET (echdr->ch_size);
5993 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5994 return sizeof (*echdr);
5995 }
5996}
5997
5998static bfd_boolean
5999process_section_headers (Filedata * filedata)
6000{
6001 Elf_Internal_Shdr * section;
6002 unsigned int i;
6003
6004 filedata->section_headers = NULL;
6005
6006 if (filedata->file_header.e_shnum == 0)
6007 {
6008 /* PR binutils/12467. */
6009 if (filedata->file_header.e_shoff != 0)
6010 {
6011 warn (_("possibly corrupt ELF file header - it has a non-zero"
6012 " section header offset, but no section headers\n"));
6013 return FALSE;
6014 }
6015 else if (do_sections)
6016 printf (_("\nThere are no sections in this file.\n"));
6017
6018 return TRUE;
6019 }
6020
6021 if (do_sections && !do_header)
6022 printf (ngettext ("There is %d section header, "
6023 "starting at offset 0x%lx:\n",
6024 "There are %d section headers, "
6025 "starting at offset 0x%lx:\n",
6026 filedata->file_header.e_shnum),
6027 filedata->file_header.e_shnum,
6028 (unsigned long) filedata->file_header.e_shoff);
6029
6030 if (is_32bit_elf)
6031 {
6032 if (! get_32bit_section_headers (filedata, FALSE))
6033 return FALSE;
6034 }
6035 else
6036 {
6037 if (! get_64bit_section_headers (filedata, FALSE))
6038 return FALSE;
6039 }
6040
6041 /* Read in the string table, so that we have names to display. */
6042 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6043 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6044 {
6045 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6046
6047 if (section->sh_size != 0)
6048 {
6049 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6050 1, section->sh_size,
6051 _("string table"));
6052
6053 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6054 }
6055 }
6056
6057 /* Scan the sections for the dynamic symbol table
6058 and dynamic string table and debug sections. */
6059 dynamic_symbols = NULL;
6060 dynamic_strings = NULL;
6061 dynamic_syminfo = NULL;
6062 symtab_shndx_list = NULL;
6063
6064 eh_addr_size = is_32bit_elf ? 4 : 8;
6065 switch (filedata->file_header.e_machine)
6066 {
6067 case EM_MIPS:
6068 case EM_MIPS_RS3_LE:
6069 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6070 FDE addresses. However, the ABI also has a semi-official ILP32
6071 variant for which the normal FDE address size rules apply.
6072
6073 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6074 section, where XX is the size of longs in bits. Unfortunately,
6075 earlier compilers provided no way of distinguishing ILP32 objects
6076 from LP64 objects, so if there's any doubt, we should assume that
6077 the official LP64 form is being used. */
6078 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6079 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6080 eh_addr_size = 8;
6081 break;
6082
6083 case EM_H8_300:
6084 case EM_H8_300H:
6085 switch (filedata->file_header.e_flags & EF_H8_MACH)
6086 {
6087 case E_H8_MACH_H8300:
6088 case E_H8_MACH_H8300HN:
6089 case E_H8_MACH_H8300SN:
6090 case E_H8_MACH_H8300SXN:
6091 eh_addr_size = 2;
6092 break;
6093 case E_H8_MACH_H8300H:
6094 case E_H8_MACH_H8300S:
6095 case E_H8_MACH_H8300SX:
6096 eh_addr_size = 4;
6097 break;
6098 }
6099 break;
6100
6101 case EM_M32C_OLD:
6102 case EM_M32C:
6103 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6104 {
6105 case EF_M32C_CPU_M16C:
6106 eh_addr_size = 2;
6107 break;
6108 }
6109 break;
6110 }
6111
6112#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6113 do \
6114 { \
6115 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6116 if (section->sh_entsize != expected_entsize) \
6117 { \
6118 char buf[40]; \
6119 sprintf_vma (buf, section->sh_entsize); \
6120 /* Note: coded this way so that there is a single string for \
6121 translation. */ \
6122 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6123 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6124 (unsigned) expected_entsize); \
6125 section->sh_entsize = expected_entsize; \
6126 } \
6127 } \
6128 while (0)
6129
6130#define CHECK_ENTSIZE(section, i, type) \
6131 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6132 sizeof (Elf64_External_##type))
6133
6134 for (i = 0, section = filedata->section_headers;
6135 i < filedata->file_header.e_shnum;
6136 i++, section++)
6137 {
6138 char * name = SECTION_NAME (section);
6139
6140 if (section->sh_type == SHT_DYNSYM)
6141 {
6142 if (dynamic_symbols != NULL)
6143 {
6144 error (_("File contains multiple dynamic symbol tables\n"));
6145 continue;
6146 }
6147
6148 CHECK_ENTSIZE (section, i, Sym);
6149 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6150 }
6151 else if (section->sh_type == SHT_STRTAB
6152 && streq (name, ".dynstr"))
6153 {
6154 if (dynamic_strings != NULL)
6155 {
6156 error (_("File contains multiple dynamic string tables\n"));
6157 continue;
6158 }
6159
6160 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6161 1, section->sh_size,
6162 _("dynamic strings"));
6163 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6164 }
6165 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6166 {
6167 elf_section_list * entry = xmalloc (sizeof * entry);
6168
6169 entry->hdr = section;
6170 entry->next = symtab_shndx_list;
6171 symtab_shndx_list = entry;
6172 }
6173 else if (section->sh_type == SHT_SYMTAB)
6174 CHECK_ENTSIZE (section, i, Sym);
6175 else if (section->sh_type == SHT_GROUP)
6176 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6177 else if (section->sh_type == SHT_REL)
6178 CHECK_ENTSIZE (section, i, Rel);
6179 else if (section->sh_type == SHT_RELA)
6180 CHECK_ENTSIZE (section, i, Rela);
6181 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6182 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6183 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6184 || do_debug_str || do_debug_loc || do_debug_ranges
6185 || do_debug_addr || do_debug_cu_index || do_debug_links)
6186 && (const_strneq (name, ".debug_")
6187 || const_strneq (name, ".zdebug_")))
6188 {
6189 if (name[1] == 'z')
6190 name += sizeof (".zdebug_") - 1;
6191 else
6192 name += sizeof (".debug_") - 1;
6193
6194 if (do_debugging
6195 || (do_debug_info && const_strneq (name, "info"))
6196 || (do_debug_info && const_strneq (name, "types"))
6197 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6198 || (do_debug_lines && strcmp (name, "line") == 0)
6199 || (do_debug_lines && const_strneq (name, "line."))
6200 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6201 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6202 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6203 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6204 || (do_debug_aranges && const_strneq (name, "aranges"))
6205 || (do_debug_ranges && const_strneq (name, "ranges"))
6206 || (do_debug_ranges && const_strneq (name, "rnglists"))
6207 || (do_debug_frames && const_strneq (name, "frame"))
6208 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6209 || (do_debug_macinfo && const_strneq (name, "macro"))
6210 || (do_debug_str && const_strneq (name, "str"))
6211 || (do_debug_loc && const_strneq (name, "loc"))
6212 || (do_debug_loc && const_strneq (name, "loclists"))
6213 || (do_debug_addr && const_strneq (name, "addr"))
6214 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6215 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6216 )
6217 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6218 }
6219 /* Linkonce section to be combined with .debug_info at link time. */
6220 else if ((do_debugging || do_debug_info)
6221 && const_strneq (name, ".gnu.linkonce.wi."))
6222 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6223 else if (do_debug_frames && streq (name, ".eh_frame"))
6224 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6225 else if (do_gdb_index && (streq (name, ".gdb_index")
6226 || streq (name, ".debug_names")))
6227 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6228 /* Trace sections for Itanium VMS. */
6229 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6230 || do_trace_aranges)
6231 && const_strneq (name, ".trace_"))
6232 {
6233 name += sizeof (".trace_") - 1;
6234
6235 if (do_debugging
6236 || (do_trace_info && streq (name, "info"))
6237 || (do_trace_abbrevs && streq (name, "abbrev"))
6238 || (do_trace_aranges && streq (name, "aranges"))
6239 )
6240 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6241 }
6242 else if ((do_debugging || do_debug_links)
6243 && (const_strneq (name, ".gnu_debuglink")
6244 || const_strneq (name, ".gnu_debugaltlink")))
6245 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6246 }
6247
6248 if (! do_sections)
6249 return TRUE;
6250
6251 if (filedata->file_header.e_shnum > 1)
6252 printf (_("\nSection Headers:\n"));
6253 else
6254 printf (_("\nSection Header:\n"));
6255
6256 if (is_32bit_elf)
6257 {
6258 if (do_section_details)
6259 {
6260 printf (_(" [Nr] Name\n"));
6261 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6262 }
6263 else
6264 printf
6265 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6266 }
6267 else if (do_wide)
6268 {
6269 if (do_section_details)
6270 {
6271 printf (_(" [Nr] Name\n"));
6272 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6273 }
6274 else
6275 printf
6276 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6277 }
6278 else
6279 {
6280 if (do_section_details)
6281 {
6282 printf (_(" [Nr] Name\n"));
6283 printf (_(" Type Address Offset Link\n"));
6284 printf (_(" Size EntSize Info Align\n"));
6285 }
6286 else
6287 {
6288 printf (_(" [Nr] Name Type Address Offset\n"));
6289 printf (_(" Size EntSize Flags Link Info Align\n"));
6290 }
6291 }
6292
6293 if (do_section_details)
6294 printf (_(" Flags\n"));
6295
6296 for (i = 0, section = filedata->section_headers;
6297 i < filedata->file_header.e_shnum;
6298 i++, section++)
6299 {
6300 /* Run some sanity checks on the section header. */
6301
6302 /* Check the sh_link field. */
6303 switch (section->sh_type)
6304 {
6305 case SHT_REL:
6306 case SHT_RELA:
6307 if (section->sh_link == 0
6308 && (filedata->file_header.e_type == ET_EXEC
6309 || filedata->file_header.e_type == ET_DYN))
6310 /* A dynamic relocation section where all entries use a
6311 zero symbol index need not specify a symtab section. */
6312 break;
6313 /* Fall through. */
6314 case SHT_SYMTAB_SHNDX:
6315 case SHT_GROUP:
6316 case SHT_HASH:
6317 case SHT_GNU_HASH:
6318 case SHT_GNU_versym:
6319 if (section->sh_link == 0
6320 || section->sh_link >= filedata->file_header.e_shnum
6321 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6322 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6323 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6324 i, section->sh_link);
6325 break;
6326
6327 case SHT_DYNAMIC:
6328 case SHT_SYMTAB:
6329 case SHT_DYNSYM:
6330 case SHT_GNU_verneed:
6331 case SHT_GNU_verdef:
6332 case SHT_GNU_LIBLIST:
6333 if (section->sh_link == 0
6334 || section->sh_link >= filedata->file_header.e_shnum
6335 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6336 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6337 i, section->sh_link);
6338 break;
6339
6340 case SHT_INIT_ARRAY:
6341 case SHT_FINI_ARRAY:
6342 case SHT_PREINIT_ARRAY:
6343 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6344 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6345 i, section->sh_link);
6346 break;
6347
6348 default:
6349 /* FIXME: Add support for target specific section types. */
6350#if 0 /* Currently we do not check other section types as there are too
6351 many special cases. Stab sections for example have a type
6352 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6353 section. */
6354 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6355 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6356 i, section->sh_link);
6357#endif
6358 break;
6359 }
6360
6361 /* Check the sh_info field. */
6362 switch (section->sh_type)
6363 {
6364 case SHT_REL:
6365 case SHT_RELA:
6366 if (section->sh_info == 0
6367 && (filedata->file_header.e_type == ET_EXEC
6368 || filedata->file_header.e_type == ET_DYN))
6369 /* Dynamic relocations apply to segments, so they do not
6370 need to specify the section they relocate. */
6371 break;
6372 if (section->sh_info == 0
6373 || section->sh_info >= filedata->file_header.e_shnum
6374 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6375 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6376 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6377 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6378 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6379 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6380 /* FIXME: Are other section types valid ? */
6381 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6382 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6383 i, section->sh_info);
6384 break;
6385
6386 case SHT_DYNAMIC:
6387 case SHT_HASH:
6388 case SHT_SYMTAB_SHNDX:
6389 case SHT_INIT_ARRAY:
6390 case SHT_FINI_ARRAY:
6391 case SHT_PREINIT_ARRAY:
6392 if (section->sh_info != 0)
6393 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6394 i, section->sh_info);
6395 break;
6396
6397 case SHT_GROUP:
6398 case SHT_SYMTAB:
6399 case SHT_DYNSYM:
6400 /* A symbol index - we assume that it is valid. */
6401 break;
6402
6403 default:
6404 /* FIXME: Add support for target specific section types. */
6405 if (section->sh_type == SHT_NOBITS)
6406 /* NOBITS section headers with non-zero sh_info fields can be
6407 created when a binary is stripped of everything but its debug
6408 information. The stripped sections have their headers
6409 preserved but their types set to SHT_NOBITS. So do not check
6410 this type of section. */
6411 ;
6412 else if (section->sh_flags & SHF_INFO_LINK)
6413 {
6414 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6415 warn (_("[%2u]: Expected link to another section in info field"), i);
6416 }
6417 else if (section->sh_type < SHT_LOOS
6418 && (section->sh_flags & SHF_GNU_MBIND) == 0
6419 && section->sh_info != 0)
6420 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6421 i, section->sh_info);
6422 break;
6423 }
6424
6425 /* Check the sh_size field. */
6426 if (section->sh_size > filedata->file_size
6427 && section->sh_type != SHT_NOBITS
6428 && section->sh_type != SHT_NULL
6429 && section->sh_type < SHT_LOOS)
6430 warn (_("Size of section %u is larger than the entire file!\n"), i);
6431
6432 printf (" [%2u] ", i);
6433 if (do_section_details)
6434 printf ("%s\n ", printable_section_name (filedata, section));
6435 else
6436 print_symbol (-17, SECTION_NAME (section));
6437
6438 printf (do_wide ? " %-15s " : " %-15.15s ",
6439 get_section_type_name (filedata, section->sh_type));
6440
6441 if (is_32bit_elf)
6442 {
6443 const char * link_too_big = NULL;
6444
6445 print_vma (section->sh_addr, LONG_HEX);
6446
6447 printf ( " %6.6lx %6.6lx %2.2lx",
6448 (unsigned long) section->sh_offset,
6449 (unsigned long) section->sh_size,
6450 (unsigned long) section->sh_entsize);
6451
6452 if (do_section_details)
6453 fputs (" ", stdout);
6454 else
6455 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6456
6457 if (section->sh_link >= filedata->file_header.e_shnum)
6458 {
6459 link_too_big = "";
6460 /* The sh_link value is out of range. Normally this indicates
6461 an error but it can have special values in Solaris binaries. */
6462 switch (filedata->file_header.e_machine)
6463 {
6464 case EM_386:
6465 case EM_IAMCU:
6466 case EM_X86_64:
6467 case EM_L1OM:
6468 case EM_K1OM:
6469 case EM_OLD_SPARCV9:
6470 case EM_SPARC32PLUS:
6471 case EM_SPARCV9:
6472 case EM_SPARC:
6473 if (section->sh_link == (SHN_BEFORE & 0xffff))
6474 link_too_big = "BEFORE";
6475 else if (section->sh_link == (SHN_AFTER & 0xffff))
6476 link_too_big = "AFTER";
6477 break;
6478 default:
6479 break;
6480 }
6481 }
6482
6483 if (do_section_details)
6484 {
6485 if (link_too_big != NULL && * link_too_big)
6486 printf ("<%s> ", link_too_big);
6487 else
6488 printf ("%2u ", section->sh_link);
6489 printf ("%3u %2lu\n", section->sh_info,
6490 (unsigned long) section->sh_addralign);
6491 }
6492 else
6493 printf ("%2u %3u %2lu\n",
6494 section->sh_link,
6495 section->sh_info,
6496 (unsigned long) section->sh_addralign);
6497
6498 if (link_too_big && ! * link_too_big)
6499 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6500 i, section->sh_link);
6501 }
6502 else if (do_wide)
6503 {
6504 print_vma (section->sh_addr, LONG_HEX);
6505
6506 if ((long) section->sh_offset == section->sh_offset)
6507 printf (" %6.6lx", (unsigned long) section->sh_offset);
6508 else
6509 {
6510 putchar (' ');
6511 print_vma (section->sh_offset, LONG_HEX);
6512 }
6513
6514 if ((unsigned long) section->sh_size == section->sh_size)
6515 printf (" %6.6lx", (unsigned long) section->sh_size);
6516 else
6517 {
6518 putchar (' ');
6519 print_vma (section->sh_size, LONG_HEX);
6520 }
6521
6522 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6523 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6524 else
6525 {
6526 putchar (' ');
6527 print_vma (section->sh_entsize, LONG_HEX);
6528 }
6529
6530 if (do_section_details)
6531 fputs (" ", stdout);
6532 else
6533 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6534
6535 printf ("%2u %3u ", section->sh_link, section->sh_info);
6536
6537 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6538 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6539 else
6540 {
6541 print_vma (section->sh_addralign, DEC);
6542 putchar ('\n');
6543 }
6544 }
6545 else if (do_section_details)
6546 {
6547 putchar (' ');
6548 print_vma (section->sh_addr, LONG_HEX);
6549 if ((long) section->sh_offset == section->sh_offset)
6550 printf (" %16.16lx", (unsigned long) section->sh_offset);
6551 else
6552 {
6553 printf (" ");
6554 print_vma (section->sh_offset, LONG_HEX);
6555 }
6556 printf (" %u\n ", section->sh_link);
6557 print_vma (section->sh_size, LONG_HEX);
6558 putchar (' ');
6559 print_vma (section->sh_entsize, LONG_HEX);
6560
6561 printf (" %-16u %lu\n",
6562 section->sh_info,
6563 (unsigned long) section->sh_addralign);
6564 }
6565 else
6566 {
6567 putchar (' ');
6568 print_vma (section->sh_addr, LONG_HEX);
6569 if ((long) section->sh_offset == section->sh_offset)
6570 printf (" %8.8lx", (unsigned long) section->sh_offset);
6571 else
6572 {
6573 printf (" ");
6574 print_vma (section->sh_offset, LONG_HEX);
6575 }
6576 printf ("\n ");
6577 print_vma (section->sh_size, LONG_HEX);
6578 printf (" ");
6579 print_vma (section->sh_entsize, LONG_HEX);
6580
6581 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6582
6583 printf (" %2u %3u %lu\n",
6584 section->sh_link,
6585 section->sh_info,
6586 (unsigned long) section->sh_addralign);
6587 }
6588
6589 if (do_section_details)
6590 {
6591 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6592 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6593 {
6594 /* Minimum section size is 12 bytes for 32-bit compression
6595 header + 12 bytes for compressed data header. */
6596 unsigned char buf[24];
6597
6598 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6599 if (get_data (&buf, filedata, section->sh_offset, 1,
6600 sizeof (buf), _("compression header")))
6601 {
6602 Elf_Internal_Chdr chdr;
6603
6604 (void) get_compression_header (&chdr, buf, sizeof (buf));
6605
6606 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6607 printf (" ZLIB, ");
6608 else
6609 printf (_(" [<unknown>: 0x%x], "),
6610 chdr.ch_type);
6611 print_vma (chdr.ch_size, LONG_HEX);
6612 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6613 }
6614 }
6615 }
6616 }
6617
6618 if (!do_section_details)
6619 {
6620 /* The ordering of the letters shown here matches the ordering of the
6621 corresponding SHF_xxx values, and hence the order in which these
6622 letters will be displayed to the user. */
6623 printf (_("Key to Flags:\n\
6624 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6625 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6626 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6627 if (filedata->file_header.e_machine == EM_X86_64
6628 || filedata->file_header.e_machine == EM_L1OM
6629 || filedata->file_header.e_machine == EM_K1OM)
6630 printf (_("l (large), "));
6631 else if (filedata->file_header.e_machine == EM_ARM)
6632 printf (_("y (purecode), "));
6633 else if (filedata->file_header.e_machine == EM_PPC)
6634 printf (_("v (VLE), "));
6635 printf ("p (processor specific)\n");
6636 }
6637
6638 return TRUE;
6639}
6640
6641static const char *
6642get_group_flags (unsigned int flags)
6643{
6644 static char buff[128];
6645
6646 if (flags == 0)
6647 return "";
6648 else if (flags == GRP_COMDAT)
6649 return "COMDAT ";
6650
6651 snprintf (buff, 14, _("[0x%x: "), flags);
6652
6653 flags &= ~ GRP_COMDAT;
6654 if (flags & GRP_MASKOS)
6655 {
6656 strcat (buff, "<OS specific>");
6657 flags &= ~ GRP_MASKOS;
6658 }
6659
6660 if (flags & GRP_MASKPROC)
6661 {
6662 strcat (buff, "<PROC specific>");
6663 flags &= ~ GRP_MASKPROC;
6664 }
6665
6666 if (flags)
6667 strcat (buff, "<unknown>");
6668
6669 strcat (buff, "]");
6670 return buff;
6671}
6672
6673static bfd_boolean
6674process_section_groups (Filedata * filedata)
6675{
6676 Elf_Internal_Shdr * section;
6677 unsigned int i;
6678 struct group * group;
6679 Elf_Internal_Shdr * symtab_sec;
6680 Elf_Internal_Shdr * strtab_sec;
6681 Elf_Internal_Sym * symtab;
6682 unsigned long num_syms;
6683 char * strtab;
6684 size_t strtab_size;
6685
6686 /* Don't process section groups unless needed. */
6687 if (!do_unwind && !do_section_groups)
6688 return TRUE;
6689
6690 if (filedata->file_header.e_shnum == 0)
6691 {
6692 if (do_section_groups)
6693 printf (_("\nThere are no sections to group in this file.\n"));
6694
6695 return TRUE;
6696 }
6697
6698 if (filedata->section_headers == NULL)
6699 {
6700 error (_("Section headers are not available!\n"));
6701 /* PR 13622: This can happen with a corrupt ELF header. */
6702 return FALSE;
6703 }
6704
6705 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6706 sizeof (struct group *));
6707
6708 if (section_headers_groups == NULL)
6709 {
6710 error (_("Out of memory reading %u section group headers\n"),
6711 filedata->file_header.e_shnum);
6712 return FALSE;
6713 }
6714
6715 /* Scan the sections for the group section. */
6716 group_count = 0;
6717 for (i = 0, section = filedata->section_headers;
6718 i < filedata->file_header.e_shnum;
6719 i++, section++)
6720 if (section->sh_type == SHT_GROUP)
6721 group_count++;
6722
6723 if (group_count == 0)
6724 {
6725 if (do_section_groups)
6726 printf (_("\nThere are no section groups in this file.\n"));
6727
6728 return TRUE;
6729 }
6730
6731 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6732
6733 if (section_groups == NULL)
6734 {
6735 error (_("Out of memory reading %lu groups\n"),
6736 (unsigned long) group_count);
6737 return FALSE;
6738 }
6739
6740 symtab_sec = NULL;
6741 strtab_sec = NULL;
6742 symtab = NULL;
6743 num_syms = 0;
6744 strtab = NULL;
6745 strtab_size = 0;
6746 for (i = 0, section = filedata->section_headers, group = section_groups;
6747 i < filedata->file_header.e_shnum;
6748 i++, section++)
6749 {
6750 if (section->sh_type == SHT_GROUP)
6751 {
6752 const char * name = printable_section_name (filedata, section);
6753 const char * group_name;
6754 unsigned char * start;
6755 unsigned char * indices;
6756 unsigned int entry, j, size;
6757 Elf_Internal_Shdr * sec;
6758 Elf_Internal_Sym * sym;
6759
6760 /* Get the symbol table. */
6761 if (section->sh_link >= filedata->file_header.e_shnum
6762 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6763 != SHT_SYMTAB))
6764 {
6765 error (_("Bad sh_link in group section `%s'\n"), name);
6766 continue;
6767 }
6768
6769 if (symtab_sec != sec)
6770 {
6771 symtab_sec = sec;
6772 if (symtab)
6773 free (symtab);
6774 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6775 }
6776
6777 if (symtab == NULL)
6778 {
6779 error (_("Corrupt header in group section `%s'\n"), name);
6780 continue;
6781 }
6782
6783 if (section->sh_info >= num_syms)
6784 {
6785 error (_("Bad sh_info in group section `%s'\n"), name);
6786 continue;
6787 }
6788
6789 sym = symtab + section->sh_info;
6790
6791 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6792 {
6793 if (sym->st_shndx == 0
6794 || sym->st_shndx >= filedata->file_header.e_shnum)
6795 {
6796 error (_("Bad sh_info in group section `%s'\n"), name);
6797 continue;
6798 }
6799
6800 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6801 strtab_sec = NULL;
6802 if (strtab)
6803 free (strtab);
6804 strtab = NULL;
6805 strtab_size = 0;
6806 }
6807 else
6808 {
6809 /* Get the string table. */
6810 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6811 {
6812 strtab_sec = NULL;
6813 if (strtab)
6814 free (strtab);
6815 strtab = NULL;
6816 strtab_size = 0;
6817 }
6818 else if (strtab_sec
6819 != (sec = filedata->section_headers + symtab_sec->sh_link))
6820 {
6821 strtab_sec = sec;
6822 if (strtab)
6823 free (strtab);
6824
6825 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6826 1, strtab_sec->sh_size,
6827 _("string table"));
6828 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6829 }
6830 group_name = sym->st_name < strtab_size
6831 ? strtab + sym->st_name : _("<corrupt>");
6832 }
6833
6834 /* PR 17531: file: loop. */
6835 if (section->sh_entsize > section->sh_size)
6836 {
6837 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6838 printable_section_name (filedata, section),
6839 (unsigned long) section->sh_entsize,
6840 (unsigned long) section->sh_size);
6841 break;
6842 }
6843
6844 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6845 1, section->sh_size,
6846 _("section data"));
6847 if (start == NULL)
6848 continue;
6849
6850 indices = start;
6851 size = (section->sh_size / section->sh_entsize) - 1;
6852 entry = byte_get (indices, 4);
6853 indices += 4;
6854
6855 if (do_section_groups)
6856 {
6857 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6858 get_group_flags (entry), i, name, group_name, size);
6859
6860 printf (_(" [Index] Name\n"));
6861 }
6862
6863 group->group_index = i;
6864
6865 for (j = 0; j < size; j++)
6866 {
6867 struct group_list * g;
6868
6869 entry = byte_get (indices, 4);
6870 indices += 4;
6871
6872 if (entry >= filedata->file_header.e_shnum)
6873 {
6874 static unsigned num_group_errors = 0;
6875
6876 if (num_group_errors ++ < 10)
6877 {
6878 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6879 entry, i, filedata->file_header.e_shnum - 1);
6880 if (num_group_errors == 10)
6881 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6882 }
6883 continue;
6884 }
6885
6886 if (section_headers_groups [entry] != NULL)
6887 {
6888 if (entry)
6889 {
6890 static unsigned num_errs = 0;
6891
6892 if (num_errs ++ < 10)
6893 {
6894 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6895 entry, i,
6896 section_headers_groups [entry]->group_index);
6897 if (num_errs == 10)
6898 warn (_("Further error messages about already contained group sections suppressed\n"));
6899 }
6900 continue;
6901 }
6902 else
6903 {
6904 /* Intel C/C++ compiler may put section 0 in a
6905 section group. We just warn it the first time
6906 and ignore it afterwards. */
6907 static bfd_boolean warned = FALSE;
6908 if (!warned)
6909 {
6910 error (_("section 0 in group section [%5u]\n"),
6911 section_headers_groups [entry]->group_index);
6912 warned = TRUE;
6913 }
6914 }
6915 }
6916
6917 section_headers_groups [entry] = group;
6918
6919 if (do_section_groups)
6920 {
6921 sec = filedata->section_headers + entry;
6922 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6923 }
6924
6925 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6926 g->section_index = entry;
6927 g->next = group->root;
6928 group->root = g;
6929 }
6930
6931 if (start)
6932 free (start);
6933
6934 group++;
6935 }
6936 }
6937
6938 if (symtab)
6939 free (symtab);
6940 if (strtab)
6941 free (strtab);
6942 return TRUE;
6943}
6944
6945/* Data used to display dynamic fixups. */
6946
6947struct ia64_vms_dynfixup
6948{
6949 bfd_vma needed_ident; /* Library ident number. */
6950 bfd_vma needed; /* Index in the dstrtab of the library name. */
6951 bfd_vma fixup_needed; /* Index of the library. */
6952 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6953 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6954};
6955
6956/* Data used to display dynamic relocations. */
6957
6958struct ia64_vms_dynimgrela
6959{
6960 bfd_vma img_rela_cnt; /* Number of relocations. */
6961 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6962};
6963
6964/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6965 library). */
6966
6967static bfd_boolean
6968dump_ia64_vms_dynamic_fixups (Filedata * filedata,
6969 struct ia64_vms_dynfixup * fixup,
6970 const char * strtab,
6971 unsigned int strtab_sz)
6972{
6973 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6974 long i;
6975 const char * lib_name;
6976
6977 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6978 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6979 _("dynamic section image fixups"));
6980 if (!imfs)
6981 return FALSE;
6982
6983 if (fixup->needed < strtab_sz)
6984 lib_name = strtab + fixup->needed;
6985 else
6986 {
6987 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6988 (unsigned long) fixup->needed);
6989 lib_name = "???";
6990 }
6991 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6992 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6993 printf
6994 (_("Seg Offset Type SymVec DataType\n"));
6995
6996 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6997 {
6998 unsigned int type;
6999 const char *rtype;
7000
7001 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7002 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7003 type = BYTE_GET (imfs [i].type);
7004 rtype = elf_ia64_reloc_type (type);
7005 if (rtype == NULL)
7006 printf (" 0x%08x ", type);
7007 else
7008 printf (" %-32s ", rtype);
7009 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7010 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7011 }
7012
7013 free (imfs);
7014 return TRUE;
7015}
7016
7017/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7018
7019static bfd_boolean
7020dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7021{
7022 Elf64_External_VMS_IMAGE_RELA *imrs;
7023 long i;
7024
7025 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7026 1, imgrela->img_rela_cnt * sizeof (*imrs),
7027 _("dynamic section image relocations"));
7028 if (!imrs)
7029 return FALSE;
7030
7031 printf (_("\nImage relocs\n"));
7032 printf
7033 (_("Seg Offset Type Addend Seg Sym Off\n"));
7034
7035 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7036 {
7037 unsigned int type;
7038 const char *rtype;
7039
7040 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7041 printf ("%08" BFD_VMA_FMT "x ",
7042 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7043 type = BYTE_GET (imrs [i].type);
7044 rtype = elf_ia64_reloc_type (type);
7045 if (rtype == NULL)
7046 printf ("0x%08x ", type);
7047 else
7048 printf ("%-31s ", rtype);
7049 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7050 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7051 printf ("%08" BFD_VMA_FMT "x\n",
7052 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7053 }
7054
7055 free (imrs);
7056 return TRUE;
7057}
7058
7059/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7060
7061static bfd_boolean
7062process_ia64_vms_dynamic_relocs (Filedata * filedata)
7063{
7064 struct ia64_vms_dynfixup fixup;
7065 struct ia64_vms_dynimgrela imgrela;
7066 Elf_Internal_Dyn *entry;
7067 bfd_vma strtab_off = 0;
7068 bfd_vma strtab_sz = 0;
7069 char *strtab = NULL;
7070 bfd_boolean res = TRUE;
7071
7072 memset (&fixup, 0, sizeof (fixup));
7073 memset (&imgrela, 0, sizeof (imgrela));
7074
7075 /* Note: the order of the entries is specified by the OpenVMS specs. */
7076 for (entry = dynamic_section;
7077 entry < dynamic_section + dynamic_nent;
7078 entry++)
7079 {
7080 switch (entry->d_tag)
7081 {
7082 case DT_IA_64_VMS_STRTAB_OFFSET:
7083 strtab_off = entry->d_un.d_val;
7084 break;
7085 case DT_STRSZ:
7086 strtab_sz = entry->d_un.d_val;
7087 if (strtab == NULL)
7088 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7089 1, strtab_sz, _("dynamic string section"));
7090 break;
7091
7092 case DT_IA_64_VMS_NEEDED_IDENT:
7093 fixup.needed_ident = entry->d_un.d_val;
7094 break;
7095 case DT_NEEDED:
7096 fixup.needed = entry->d_un.d_val;
7097 break;
7098 case DT_IA_64_VMS_FIXUP_NEEDED:
7099 fixup.fixup_needed = entry->d_un.d_val;
7100 break;
7101 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7102 fixup.fixup_rela_cnt = entry->d_un.d_val;
7103 break;
7104 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7105 fixup.fixup_rela_off = entry->d_un.d_val;
7106 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7107 res = FALSE;
7108 break;
7109 case DT_IA_64_VMS_IMG_RELA_CNT:
7110 imgrela.img_rela_cnt = entry->d_un.d_val;
7111 break;
7112 case DT_IA_64_VMS_IMG_RELA_OFF:
7113 imgrela.img_rela_off = entry->d_un.d_val;
7114 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7115 res = FALSE;
7116 break;
7117
7118 default:
7119 break;
7120 }
7121 }
7122
7123 if (strtab != NULL)
7124 free (strtab);
7125
7126 return res;
7127}
7128
7129static struct
7130{
7131 const char * name;
7132 int reloc;
7133 int size;
7134 int rela;
7135}
7136 dynamic_relocations [] =
7137{
7138 { "REL", DT_REL, DT_RELSZ, FALSE },
7139 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7140 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7141};
7142
7143/* Process the reloc section. */
7144
7145static bfd_boolean
7146process_relocs (Filedata * filedata)
7147{
7148 unsigned long rel_size;
7149 unsigned long rel_offset;
7150
7151 if (!do_reloc)
7152 return TRUE;
7153
7154 if (do_using_dynamic)
7155 {
7156 int is_rela;
7157 const char * name;
7158 bfd_boolean has_dynamic_reloc;
7159 unsigned int i;
7160
7161 has_dynamic_reloc = FALSE;
7162
7163 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7164 {
7165 is_rela = dynamic_relocations [i].rela;
7166 name = dynamic_relocations [i].name;
7167 rel_size = dynamic_info [dynamic_relocations [i].size];
7168 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7169
7170 if (rel_size)
7171 has_dynamic_reloc = TRUE;
7172
7173 if (is_rela == UNKNOWN)
7174 {
7175 if (dynamic_relocations [i].reloc == DT_JMPREL)
7176 switch (dynamic_info[DT_PLTREL])
7177 {
7178 case DT_REL:
7179 is_rela = FALSE;
7180 break;
7181 case DT_RELA:
7182 is_rela = TRUE;
7183 break;
7184 }
7185 }
7186
7187 if (rel_size)
7188 {
7189 printf
7190 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7191 name, rel_offset, rel_size);
7192
7193 dump_relocations (filedata,
7194 offset_from_vma (filedata, rel_offset, rel_size),
7195 rel_size,
7196 dynamic_symbols, num_dynamic_syms,
7197 dynamic_strings, dynamic_strings_length,
7198 is_rela, TRUE /* is_dynamic */);
7199 }
7200 }
7201
7202 if (is_ia64_vms (filedata))
7203 if (process_ia64_vms_dynamic_relocs (filedata))
7204 has_dynamic_reloc = TRUE;
7205
7206 if (! has_dynamic_reloc)
7207 printf (_("\nThere are no dynamic relocations in this file.\n"));
7208 }
7209 else
7210 {
7211 Elf_Internal_Shdr * section;
7212 unsigned long i;
7213 bfd_boolean found = FALSE;
7214
7215 for (i = 0, section = filedata->section_headers;
7216 i < filedata->file_header.e_shnum;
7217 i++, section++)
7218 {
7219 if ( section->sh_type != SHT_RELA
7220 && section->sh_type != SHT_REL)
7221 continue;
7222
7223 rel_offset = section->sh_offset;
7224 rel_size = section->sh_size;
7225
7226 if (rel_size)
7227 {
7228 Elf_Internal_Shdr * strsec;
7229 int is_rela;
7230 unsigned long num_rela;
7231
7232 printf (_("\nRelocation section "));
7233
7234 if (filedata->string_table == NULL)
7235 printf ("%d", section->sh_name);
7236 else
7237 printf ("'%s'", printable_section_name (filedata, section));
7238
7239 num_rela = rel_size / section->sh_entsize;
7240 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7241 " at offset 0x%lx contains %lu entries:\n",
7242 num_rela),
7243 rel_offset, num_rela);
7244
7245 is_rela = section->sh_type == SHT_RELA;
7246
7247 if (section->sh_link != 0
7248 && section->sh_link < filedata->file_header.e_shnum)
7249 {
7250 Elf_Internal_Shdr * symsec;
7251 Elf_Internal_Sym * symtab;
7252 unsigned long nsyms;
7253 unsigned long strtablen = 0;
7254 char * strtab = NULL;
7255
7256 symsec = filedata->section_headers + section->sh_link;
7257 if (symsec->sh_type != SHT_SYMTAB
7258 && symsec->sh_type != SHT_DYNSYM)
7259 continue;
7260
7261 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7262
7263 if (symtab == NULL)
7264 continue;
7265
7266 if (symsec->sh_link != 0
7267 && symsec->sh_link < filedata->file_header.e_shnum)
7268 {
7269 strsec = filedata->section_headers + symsec->sh_link;
7270
7271 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7272 1, strsec->sh_size,
7273 _("string table"));
7274 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7275 }
7276
7277 dump_relocations (filedata, rel_offset, rel_size,
7278 symtab, nsyms, strtab, strtablen,
7279 is_rela,
7280 symsec->sh_type == SHT_DYNSYM);
7281 if (strtab)
7282 free (strtab);
7283 free (symtab);
7284 }
7285 else
7286 dump_relocations (filedata, rel_offset, rel_size,
7287 NULL, 0, NULL, 0, is_rela,
7288 FALSE /* is_dynamic */);
7289
7290 found = TRUE;
7291 }
7292 }
7293
7294 if (! found)
7295 {
7296 /* Users sometimes forget the -D option, so try to be helpful. */
7297 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7298 {
7299 if (dynamic_info [dynamic_relocations [i].size])
7300 {
7301 printf (_("\nThere are no static relocations in this file."));
7302 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7303
7304 break;
7305 }
7306 }
7307 if (i == ARRAY_SIZE (dynamic_relocations))
7308 printf (_("\nThere are no relocations in this file.\n"));
7309 }
7310 }
7311
7312 return TRUE;
7313}
7314
7315/* An absolute address consists of a section and an offset. If the
7316 section is NULL, the offset itself is the address, otherwise, the
7317 address equals to LOAD_ADDRESS(section) + offset. */
7318
7319struct absaddr
7320{
7321 unsigned short section;
7322 bfd_vma offset;
7323};
7324
7325#define ABSADDR(a) \
7326 ((a).section \
7327 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7328 : (a).offset)
7329
7330/* Find the nearest symbol at or below ADDR. Returns the symbol
7331 name, if found, and the offset from the symbol to ADDR. */
7332
7333static void
7334find_symbol_for_address (Filedata * filedata,
7335 Elf_Internal_Sym * symtab,
7336 unsigned long nsyms,
7337 const char * strtab,
7338 unsigned long strtab_size,
7339 struct absaddr addr,
7340 const char ** symname,
7341 bfd_vma * offset)
7342{
7343 bfd_vma dist = 0x100000;
7344 Elf_Internal_Sym * sym;
7345 Elf_Internal_Sym * beg;
7346 Elf_Internal_Sym * end;
7347 Elf_Internal_Sym * best = NULL;
7348
7349 REMOVE_ARCH_BITS (addr.offset);
7350 beg = symtab;
7351 end = symtab + nsyms;
7352
7353 while (beg < end)
7354 {
7355 bfd_vma value;
7356
7357 sym = beg + (end - beg) / 2;
7358
7359 value = sym->st_value;
7360 REMOVE_ARCH_BITS (value);
7361
7362 if (sym->st_name != 0
7363 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7364 && addr.offset >= value
7365 && addr.offset - value < dist)
7366 {
7367 best = sym;
7368 dist = addr.offset - value;
7369 if (!dist)
7370 break;
7371 }
7372
7373 if (addr.offset < value)
7374 end = sym;
7375 else
7376 beg = sym + 1;
7377 }
7378
7379 if (best)
7380 {
7381 *symname = (best->st_name >= strtab_size
7382 ? _("<corrupt>") : strtab + best->st_name);
7383 *offset = dist;
7384 return;
7385 }
7386
7387 *symname = NULL;
7388 *offset = addr.offset;
7389}
7390
7391static /* signed */ int
7392symcmp (const void *p, const void *q)
7393{
7394 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7395 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7396
7397 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7398}
7399
7400/* Process the unwind section. */
7401
7402#include "unwind-ia64.h"
7403
7404struct ia64_unw_table_entry
7405{
7406 struct absaddr start;
7407 struct absaddr end;
7408 struct absaddr info;
7409};
7410
7411struct ia64_unw_aux_info
7412{
7413 struct ia64_unw_table_entry * table; /* Unwind table. */
7414 unsigned long table_len; /* Length of unwind table. */
7415 unsigned char * info; /* Unwind info. */
7416 unsigned long info_size; /* Size of unwind info. */
7417 bfd_vma info_addr; /* Starting address of unwind info. */
7418 bfd_vma seg_base; /* Starting address of segment. */
7419 Elf_Internal_Sym * symtab; /* The symbol table. */
7420 unsigned long nsyms; /* Number of symbols. */
7421 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7422 unsigned long nfuns; /* Number of entries in funtab. */
7423 char * strtab; /* The string table. */
7424 unsigned long strtab_size; /* Size of string table. */
7425};
7426
7427static bfd_boolean
7428dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7429{
7430 struct ia64_unw_table_entry * tp;
7431 unsigned long j, nfuns;
7432 int in_body;
7433 bfd_boolean res = TRUE;
7434
7435 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7436 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7437 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7438 aux->funtab[nfuns++] = aux->symtab[j];
7439 aux->nfuns = nfuns;
7440 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7441
7442 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7443 {
7444 bfd_vma stamp;
7445 bfd_vma offset;
7446 const unsigned char * dp;
7447 const unsigned char * head;
7448 const unsigned char * end;
7449 const char * procname;
7450
7451 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7452 aux->strtab_size, tp->start, &procname, &offset);
7453
7454 fputs ("\n<", stdout);
7455
7456 if (procname)
7457 {
7458 fputs (procname, stdout);
7459
7460 if (offset)
7461 printf ("+%lx", (unsigned long) offset);
7462 }
7463
7464 fputs (">: [", stdout);
7465 print_vma (tp->start.offset, PREFIX_HEX);
7466 fputc ('-', stdout);
7467 print_vma (tp->end.offset, PREFIX_HEX);
7468 printf ("], info at +0x%lx\n",
7469 (unsigned long) (tp->info.offset - aux->seg_base));
7470
7471 /* PR 17531: file: 86232b32. */
7472 if (aux->info == NULL)
7473 continue;
7474
7475 /* PR 17531: file: 0997b4d1. */
7476 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7477 {
7478 warn (_("Invalid offset %lx in table entry %ld\n"),
7479 (long) tp->info.offset, (long) (tp - aux->table));
7480 res = FALSE;
7481 continue;
7482 }
7483
7484 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7485 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7486
7487 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7488 (unsigned) UNW_VER (stamp),
7489 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7490 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7491 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7492 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7493
7494 if (UNW_VER (stamp) != 1)
7495 {
7496 printf (_("\tUnknown version.\n"));
7497 continue;
7498 }
7499
7500 in_body = 0;
7501 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7502 /* PR 17531: file: 16ceda89. */
7503 if (end > aux->info + aux->info_size)
7504 end = aux->info + aux->info_size;
7505 for (dp = head + 8; dp < end;)
7506 dp = unw_decode (dp, in_body, & in_body, end);
7507 }
7508
7509 free (aux->funtab);
7510
7511 return res;
7512}
7513
7514static bfd_boolean
7515slurp_ia64_unwind_table (Filedata * filedata,
7516 struct ia64_unw_aux_info * aux,
7517 Elf_Internal_Shdr * sec)
7518{
7519 unsigned long size, nrelas, i;
7520 Elf_Internal_Phdr * seg;
7521 struct ia64_unw_table_entry * tep;
7522 Elf_Internal_Shdr * relsec;
7523 Elf_Internal_Rela * rela;
7524 Elf_Internal_Rela * rp;
7525 unsigned char * table;
7526 unsigned char * tp;
7527 Elf_Internal_Sym * sym;
7528 const char * relname;
7529
7530 aux->table_len = 0;
7531
7532 /* First, find the starting address of the segment that includes
7533 this section: */
7534
7535 if (filedata->file_header.e_phnum)
7536 {
7537 if (! get_program_headers (filedata))
7538 return FALSE;
7539
7540 for (seg = filedata->program_headers;
7541 seg < filedata->program_headers + filedata->file_header.e_phnum;
7542 ++seg)
7543 {
7544 if (seg->p_type != PT_LOAD)
7545 continue;
7546
7547 if (sec->sh_addr >= seg->p_vaddr
7548 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7549 {
7550 aux->seg_base = seg->p_vaddr;
7551 break;
7552 }
7553 }
7554 }
7555
7556 /* Second, build the unwind table from the contents of the unwind section: */
7557 size = sec->sh_size;
7558 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7559 _("unwind table"));
7560 if (!table)
7561 return FALSE;
7562
7563 aux->table_len = size / (3 * eh_addr_size);
7564 aux->table = (struct ia64_unw_table_entry *)
7565 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7566 tep = aux->table;
7567
7568 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7569 {
7570 tep->start.section = SHN_UNDEF;
7571 tep->end.section = SHN_UNDEF;
7572 tep->info.section = SHN_UNDEF;
7573 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7574 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7575 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7576 tep->start.offset += aux->seg_base;
7577 tep->end.offset += aux->seg_base;
7578 tep->info.offset += aux->seg_base;
7579 }
7580 free (table);
7581
7582 /* Third, apply any relocations to the unwind table: */
7583 for (relsec = filedata->section_headers;
7584 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7585 ++relsec)
7586 {
7587 if (relsec->sh_type != SHT_RELA
7588 || relsec->sh_info >= filedata->file_header.e_shnum
7589 || filedata->section_headers + relsec->sh_info != sec)
7590 continue;
7591
7592 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7593 & rela, & nrelas))
7594 {
7595 free (aux->table);
7596 aux->table = NULL;
7597 aux->table_len = 0;
7598 return FALSE;
7599 }
7600
7601 for (rp = rela; rp < rela + nrelas; ++rp)
7602 {
7603 unsigned int sym_ndx;
7604 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7605 relname = elf_ia64_reloc_type (r_type);
7606
7607 /* PR 17531: file: 9fa67536. */
7608 if (relname == NULL)
7609 {
7610 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7611 continue;
7612 }
7613
7614 if (! const_strneq (relname, "R_IA64_SEGREL"))
7615 {
7616 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7617 continue;
7618 }
7619
7620 i = rp->r_offset / (3 * eh_addr_size);
7621
7622 /* PR 17531: file: 5bc8d9bf. */
7623 if (i >= aux->table_len)
7624 {
7625 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7626 continue;
7627 }
7628
7629 sym_ndx = get_reloc_symindex (rp->r_info);
7630 if (sym_ndx >= aux->nsyms)
7631 {
7632 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7633 sym_ndx);
7634 continue;
7635 }
7636 sym = aux->symtab + sym_ndx;
7637
7638 switch (rp->r_offset / eh_addr_size % 3)
7639 {
7640 case 0:
7641 aux->table[i].start.section = sym->st_shndx;
7642 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7643 break;
7644 case 1:
7645 aux->table[i].end.section = sym->st_shndx;
7646 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7647 break;
7648 case 2:
7649 aux->table[i].info.section = sym->st_shndx;
7650 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7651 break;
7652 default:
7653 break;
7654 }
7655 }
7656
7657 free (rela);
7658 }
7659
7660 return TRUE;
7661}
7662
7663static bfd_boolean
7664ia64_process_unwind (Filedata * filedata)
7665{
7666 Elf_Internal_Shdr * sec;
7667 Elf_Internal_Shdr * unwsec = NULL;
7668 Elf_Internal_Shdr * strsec;
7669 unsigned long i, unwcount = 0, unwstart = 0;
7670 struct ia64_unw_aux_info aux;
7671 bfd_boolean res = TRUE;
7672
7673 memset (& aux, 0, sizeof (aux));
7674
7675 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7676 {
7677 if (sec->sh_type == SHT_SYMTAB
7678 && sec->sh_link < filedata->file_header.e_shnum)
7679 {
7680 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7681
7682 strsec = filedata->section_headers + sec->sh_link;
7683 if (aux.strtab != NULL)
7684 {
7685 error (_("Multiple auxillary string tables encountered\n"));
7686 free (aux.strtab);
7687 res = FALSE;
7688 }
7689 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7690 1, strsec->sh_size,
7691 _("string table"));
7692 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7693 }
7694 else if (sec->sh_type == SHT_IA_64_UNWIND)
7695 unwcount++;
7696 }
7697
7698 if (!unwcount)
7699 printf (_("\nThere are no unwind sections in this file.\n"));
7700
7701 while (unwcount-- > 0)
7702 {
7703 char * suffix;
7704 size_t len, len2;
7705
7706 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7707 i < filedata->file_header.e_shnum; ++i, ++sec)
7708 if (sec->sh_type == SHT_IA_64_UNWIND)
7709 {
7710 unwsec = sec;
7711 break;
7712 }
7713 /* We have already counted the number of SHT_IA64_UNWIND
7714 sections so the loop above should never fail. */
7715 assert (unwsec != NULL);
7716
7717 unwstart = i + 1;
7718 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7719
7720 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7721 {
7722 /* We need to find which section group it is in. */
7723 struct group_list * g;
7724
7725 if (section_headers_groups == NULL
7726 || section_headers_groups [i] == NULL)
7727 i = filedata->file_header.e_shnum;
7728 else
7729 {
7730 g = section_headers_groups [i]->root;
7731
7732 for (; g != NULL; g = g->next)
7733 {
7734 sec = filedata->section_headers + g->section_index;
7735
7736 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7737 break;
7738 }
7739
7740 if (g == NULL)
7741 i = filedata->file_header.e_shnum;
7742 }
7743 }
7744 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7745 {
7746 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7747 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7748 suffix = SECTION_NAME (unwsec) + len;
7749 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7750 ++i, ++sec)
7751 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7752 && streq (SECTION_NAME (sec) + len2, suffix))
7753 break;
7754 }
7755 else
7756 {
7757 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7758 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7759 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7760 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7761 suffix = "";
7762 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7763 suffix = SECTION_NAME (unwsec) + len;
7764 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7765 ++i, ++sec)
7766 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7767 && streq (SECTION_NAME (sec) + len2, suffix))
7768 break;
7769 }
7770
7771 if (i == filedata->file_header.e_shnum)
7772 {
7773 printf (_("\nCould not find unwind info section for "));
7774
7775 if (filedata->string_table == NULL)
7776 printf ("%d", unwsec->sh_name);
7777 else
7778 printf ("'%s'", printable_section_name (filedata, unwsec));
7779 }
7780 else
7781 {
7782 aux.info_addr = sec->sh_addr;
7783 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7784 sec->sh_size,
7785 _("unwind info"));
7786 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7787
7788 printf (_("\nUnwind section "));
7789
7790 if (filedata->string_table == NULL)
7791 printf ("%d", unwsec->sh_name);
7792 else
7793 printf ("'%s'", printable_section_name (filedata, unwsec));
7794
7795 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7796 (unsigned long) unwsec->sh_offset,
7797 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7798
7799 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7800 && aux.table_len > 0)
7801 dump_ia64_unwind (filedata, & aux);
7802
7803 if (aux.table)
7804 free ((char *) aux.table);
7805 if (aux.info)
7806 free ((char *) aux.info);
7807 aux.table = NULL;
7808 aux.info = NULL;
7809 }
7810 }
7811
7812 if (aux.symtab)
7813 free (aux.symtab);
7814 if (aux.strtab)
7815 free ((char *) aux.strtab);
7816
7817 return res;
7818}
7819
7820struct hppa_unw_table_entry
7821{
7822 struct absaddr start;
7823 struct absaddr end;
7824 unsigned int Cannot_unwind:1; /* 0 */
7825 unsigned int Millicode:1; /* 1 */
7826 unsigned int Millicode_save_sr0:1; /* 2 */
7827 unsigned int Region_description:2; /* 3..4 */
7828 unsigned int reserved1:1; /* 5 */
7829 unsigned int Entry_SR:1; /* 6 */
7830 unsigned int Entry_FR:4; /* Number saved 7..10 */
7831 unsigned int Entry_GR:5; /* Number saved 11..15 */
7832 unsigned int Args_stored:1; /* 16 */
7833 unsigned int Variable_Frame:1; /* 17 */
7834 unsigned int Separate_Package_Body:1; /* 18 */
7835 unsigned int Frame_Extension_Millicode:1; /* 19 */
7836 unsigned int Stack_Overflow_Check:1; /* 20 */
7837 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7838 unsigned int Ada_Region:1; /* 22 */
7839 unsigned int cxx_info:1; /* 23 */
7840 unsigned int cxx_try_catch:1; /* 24 */
7841 unsigned int sched_entry_seq:1; /* 25 */
7842 unsigned int reserved2:1; /* 26 */
7843 unsigned int Save_SP:1; /* 27 */
7844 unsigned int Save_RP:1; /* 28 */
7845 unsigned int Save_MRP_in_frame:1; /* 29 */
7846 unsigned int extn_ptr_defined:1; /* 30 */
7847 unsigned int Cleanup_defined:1; /* 31 */
7848
7849 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7850 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7851 unsigned int Large_frame:1; /* 2 */
7852 unsigned int Pseudo_SP_Set:1; /* 3 */
7853 unsigned int reserved4:1; /* 4 */
7854 unsigned int Total_frame_size:27; /* 5..31 */
7855};
7856
7857struct hppa_unw_aux_info
7858{
7859 struct hppa_unw_table_entry * table; /* Unwind table. */
7860 unsigned long table_len; /* Length of unwind table. */
7861 bfd_vma seg_base; /* Starting address of segment. */
7862 Elf_Internal_Sym * symtab; /* The symbol table. */
7863 unsigned long nsyms; /* Number of symbols. */
7864 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7865 unsigned long nfuns; /* Number of entries in funtab. */
7866 char * strtab; /* The string table. */
7867 unsigned long strtab_size; /* Size of string table. */
7868};
7869
7870static bfd_boolean
7871dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7872{
7873 struct hppa_unw_table_entry * tp;
7874 unsigned long j, nfuns;
7875 bfd_boolean res = TRUE;
7876
7877 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7878 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7879 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7880 aux->funtab[nfuns++] = aux->symtab[j];
7881 aux->nfuns = nfuns;
7882 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7883
7884 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7885 {
7886 bfd_vma offset;
7887 const char * procname;
7888
7889 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7890 aux->strtab_size, tp->start, &procname,
7891 &offset);
7892
7893 fputs ("\n<", stdout);
7894
7895 if (procname)
7896 {
7897 fputs (procname, stdout);
7898
7899 if (offset)
7900 printf ("+%lx", (unsigned long) offset);
7901 }
7902
7903 fputs (">: [", stdout);
7904 print_vma (tp->start.offset, PREFIX_HEX);
7905 fputc ('-', stdout);
7906 print_vma (tp->end.offset, PREFIX_HEX);
7907 printf ("]\n\t");
7908
7909#define PF(_m) if (tp->_m) printf (#_m " ");
7910#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7911 PF(Cannot_unwind);
7912 PF(Millicode);
7913 PF(Millicode_save_sr0);
7914 /* PV(Region_description); */
7915 PF(Entry_SR);
7916 PV(Entry_FR);
7917 PV(Entry_GR);
7918 PF(Args_stored);
7919 PF(Variable_Frame);
7920 PF(Separate_Package_Body);
7921 PF(Frame_Extension_Millicode);
7922 PF(Stack_Overflow_Check);
7923 PF(Two_Instruction_SP_Increment);
7924 PF(Ada_Region);
7925 PF(cxx_info);
7926 PF(cxx_try_catch);
7927 PF(sched_entry_seq);
7928 PF(Save_SP);
7929 PF(Save_RP);
7930 PF(Save_MRP_in_frame);
7931 PF(extn_ptr_defined);
7932 PF(Cleanup_defined);
7933 PF(MPE_XL_interrupt_marker);
7934 PF(HP_UX_interrupt_marker);
7935 PF(Large_frame);
7936 PF(Pseudo_SP_Set);
7937 PV(Total_frame_size);
7938#undef PF
7939#undef PV
7940 }
7941
7942 printf ("\n");
7943
7944 free (aux->funtab);
7945
7946 return res;
7947}
7948
7949static bfd_boolean
7950slurp_hppa_unwind_table (Filedata * filedata,
7951 struct hppa_unw_aux_info * aux,
7952 Elf_Internal_Shdr * sec)
7953{
7954 unsigned long size, unw_ent_size, nentries, nrelas, i;
7955 Elf_Internal_Phdr * seg;
7956 struct hppa_unw_table_entry * tep;
7957 Elf_Internal_Shdr * relsec;
7958 Elf_Internal_Rela * rela;
7959 Elf_Internal_Rela * rp;
7960 unsigned char * table;
7961 unsigned char * tp;
7962 Elf_Internal_Sym * sym;
7963 const char * relname;
7964
7965 /* First, find the starting address of the segment that includes
7966 this section. */
7967 if (filedata->file_header.e_phnum)
7968 {
7969 if (! get_program_headers (filedata))
7970 return FALSE;
7971
7972 for (seg = filedata->program_headers;
7973 seg < filedata->program_headers + filedata->file_header.e_phnum;
7974 ++seg)
7975 {
7976 if (seg->p_type != PT_LOAD)
7977 continue;
7978
7979 if (sec->sh_addr >= seg->p_vaddr
7980 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7981 {
7982 aux->seg_base = seg->p_vaddr;
7983 break;
7984 }
7985 }
7986 }
7987
7988 /* Second, build the unwind table from the contents of the unwind
7989 section. */
7990 size = sec->sh_size;
7991 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7992 _("unwind table"));
7993 if (!table)
7994 return FALSE;
7995
7996 unw_ent_size = 16;
7997 nentries = size / unw_ent_size;
7998 size = unw_ent_size * nentries;
7999
8000 tep = aux->table = (struct hppa_unw_table_entry *)
8001 xcmalloc (nentries, sizeof (aux->table[0]));
8002
8003 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8004 {
8005 unsigned int tmp1, tmp2;
8006
8007 tep->start.section = SHN_UNDEF;
8008 tep->end.section = SHN_UNDEF;
8009
8010 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8011 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8012 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8013 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8014
8015 tep->start.offset += aux->seg_base;
8016 tep->end.offset += aux->seg_base;
8017
8018 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8019 tep->Millicode = (tmp1 >> 30) & 0x1;
8020 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8021 tep->Region_description = (tmp1 >> 27) & 0x3;
8022 tep->reserved1 = (tmp1 >> 26) & 0x1;
8023 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8024 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8025 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8026 tep->Args_stored = (tmp1 >> 15) & 0x1;
8027 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8028 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8029 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8030 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8031 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8032 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8033 tep->cxx_info = (tmp1 >> 8) & 0x1;
8034 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8035 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8036 tep->reserved2 = (tmp1 >> 5) & 0x1;
8037 tep->Save_SP = (tmp1 >> 4) & 0x1;
8038 tep->Save_RP = (tmp1 >> 3) & 0x1;
8039 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8040 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8041 tep->Cleanup_defined = tmp1 & 0x1;
8042
8043 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8044 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8045 tep->Large_frame = (tmp2 >> 29) & 0x1;
8046 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8047 tep->reserved4 = (tmp2 >> 27) & 0x1;
8048 tep->Total_frame_size = tmp2 & 0x7ffffff;
8049 }
8050 free (table);
8051
8052 /* Third, apply any relocations to the unwind table. */
8053 for (relsec = filedata->section_headers;
8054 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8055 ++relsec)
8056 {
8057 if (relsec->sh_type != SHT_RELA
8058 || relsec->sh_info >= filedata->file_header.e_shnum
8059 || filedata->section_headers + relsec->sh_info != sec)
8060 continue;
8061
8062 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8063 & rela, & nrelas))
8064 return FALSE;
8065
8066 for (rp = rela; rp < rela + nrelas; ++rp)
8067 {
8068 unsigned int sym_ndx;
8069 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8070 relname = elf_hppa_reloc_type (r_type);
8071
8072 if (relname == NULL)
8073 {
8074 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8075 continue;
8076 }
8077
8078 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8079 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8080 {
8081 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8082 continue;
8083 }
8084
8085 i = rp->r_offset / unw_ent_size;
8086 if (i >= aux->table_len)
8087 {
8088 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8089 continue;
8090 }
8091
8092 sym_ndx = get_reloc_symindex (rp->r_info);
8093 if (sym_ndx >= aux->nsyms)
8094 {
8095 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8096 sym_ndx);
8097 continue;
8098 }
8099 sym = aux->symtab + sym_ndx;
8100
8101 switch ((rp->r_offset % unw_ent_size) / 4)
8102 {
8103 case 0:
8104 aux->table[i].start.section = sym->st_shndx;
8105 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8106 break;
8107 case 1:
8108 aux->table[i].end.section = sym->st_shndx;
8109 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8110 break;
8111 default:
8112 break;
8113 }
8114 }
8115
8116 free (rela);
8117 }
8118
8119 aux->table_len = nentries;
8120
8121 return TRUE;
8122}
8123
8124static bfd_boolean
8125hppa_process_unwind (Filedata * filedata)
8126{
8127 struct hppa_unw_aux_info aux;
8128 Elf_Internal_Shdr * unwsec = NULL;
8129 Elf_Internal_Shdr * strsec;
8130 Elf_Internal_Shdr * sec;
8131 unsigned long i;
8132 bfd_boolean res = TRUE;
8133
8134 if (filedata->string_table == NULL)
8135 return FALSE;
8136
8137 memset (& aux, 0, sizeof (aux));
8138
8139 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8140 {
8141 if (sec->sh_type == SHT_SYMTAB
8142 && sec->sh_link < filedata->file_header.e_shnum)
8143 {
8144 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8145
8146 strsec = filedata->section_headers + sec->sh_link;
8147 if (aux.strtab != NULL)
8148 {
8149 error (_("Multiple auxillary string tables encountered\n"));
8150 free (aux.strtab);
8151 res = FALSE;
8152 }
8153 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8154 1, strsec->sh_size,
8155 _("string table"));
8156 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8157 }
8158 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8159 unwsec = sec;
8160 }
8161
8162 if (!unwsec)
8163 printf (_("\nThere are no unwind sections in this file.\n"));
8164
8165 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8166 {
8167 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8168 {
8169 unsigned long num_unwind = sec->sh_size / 16;
8170
8171 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8172 "contains %lu entry:\n",
8173 "\nUnwind section '%s' at offset 0x%lx "
8174 "contains %lu entries:\n",
8175 num_unwind),
8176 printable_section_name (filedata, sec),
8177 (unsigned long) sec->sh_offset,
8178 num_unwind);
8179
8180 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8181 res = FALSE;
8182
8183 if (res && aux.table_len > 0)
8184 {
8185 if (! dump_hppa_unwind (filedata, &aux))
8186 res = FALSE;
8187 }
8188
8189 if (aux.table)
8190 free ((char *) aux.table);
8191 aux.table = NULL;
8192 }
8193 }
8194
8195 if (aux.symtab)
8196 free (aux.symtab);
8197 if (aux.strtab)
8198 free ((char *) aux.strtab);
8199
8200 return res;
8201}
8202
8203struct arm_section
8204{
8205 unsigned char * data; /* The unwind data. */
8206 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8207 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8208 unsigned long nrelas; /* The number of relocations. */
8209 unsigned int rel_type; /* REL or RELA ? */
8210 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8211};
8212
8213struct arm_unw_aux_info
8214{
8215 Filedata * filedata; /* The file containing the unwind sections. */
8216 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8217 unsigned long nsyms; /* Number of symbols. */
8218 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8219 unsigned long nfuns; /* Number of these symbols. */
8220 char * strtab; /* The file's string table. */
8221 unsigned long strtab_size; /* Size of string table. */
8222};
8223
8224static const char *
8225arm_print_vma_and_name (Filedata * filedata,
8226 struct arm_unw_aux_info * aux,
8227 bfd_vma fn,
8228 struct absaddr addr)
8229{
8230 const char *procname;
8231 bfd_vma sym_offset;
8232
8233 if (addr.section == SHN_UNDEF)
8234 addr.offset = fn;
8235
8236 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8237 aux->strtab_size, addr, &procname,
8238 &sym_offset);
8239
8240 print_vma (fn, PREFIX_HEX);
8241
8242 if (procname)
8243 {
8244 fputs (" <", stdout);
8245 fputs (procname, stdout);
8246
8247 if (sym_offset)
8248 printf ("+0x%lx", (unsigned long) sym_offset);
8249 fputc ('>', stdout);
8250 }
8251
8252 return procname;
8253}
8254
8255static void
8256arm_free_section (struct arm_section *arm_sec)
8257{
8258 if (arm_sec->data != NULL)
8259 free (arm_sec->data);
8260
8261 if (arm_sec->rela != NULL)
8262 free (arm_sec->rela);
8263}
8264
8265/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8266 cached section and install SEC instead.
8267 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8268 and return its valued in * WORDP, relocating if necessary.
8269 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8270 relocation's offset in ADDR.
8271 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8272 into the string table of the symbol associated with the reloc. If no
8273 reloc was applied store -1 there.
8274 5) Return TRUE upon success, FALSE otherwise. */
8275
8276static bfd_boolean
8277get_unwind_section_word (Filedata * filedata,
8278 struct arm_unw_aux_info * aux,
8279 struct arm_section * arm_sec,
8280 Elf_Internal_Shdr * sec,
8281 bfd_vma word_offset,
8282 unsigned int * wordp,
8283 struct absaddr * addr,
8284 bfd_vma * sym_name)
8285{
8286 Elf_Internal_Rela *rp;
8287 Elf_Internal_Sym *sym;
8288 const char * relname;
8289 unsigned int word;
8290 bfd_boolean wrapped;
8291
8292 if (sec == NULL || arm_sec == NULL)
8293 return FALSE;
8294
8295 addr->section = SHN_UNDEF;
8296 addr->offset = 0;
8297
8298 if (sym_name != NULL)
8299 *sym_name = (bfd_vma) -1;
8300
8301 /* If necessary, update the section cache. */
8302 if (sec != arm_sec->sec)
8303 {
8304 Elf_Internal_Shdr *relsec;
8305
8306 arm_free_section (arm_sec);
8307
8308 arm_sec->sec = sec;
8309 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8310 sec->sh_size, _("unwind data"));
8311 arm_sec->rela = NULL;
8312 arm_sec->nrelas = 0;
8313
8314 for (relsec = filedata->section_headers;
8315 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8316 ++relsec)
8317 {
8318 if (relsec->sh_info >= filedata->file_header.e_shnum
8319 || filedata->section_headers + relsec->sh_info != sec
8320 /* PR 15745: Check the section type as well. */
8321 || (relsec->sh_type != SHT_REL
8322 && relsec->sh_type != SHT_RELA))
8323 continue;
8324
8325 arm_sec->rel_type = relsec->sh_type;
8326 if (relsec->sh_type == SHT_REL)
8327 {
8328 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8329 relsec->sh_size,
8330 & arm_sec->rela, & arm_sec->nrelas))
8331 return FALSE;
8332 }
8333 else /* relsec->sh_type == SHT_RELA */
8334 {
8335 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8336 relsec->sh_size,
8337 & arm_sec->rela, & arm_sec->nrelas))
8338 return FALSE;
8339 }
8340 break;
8341 }
8342
8343 arm_sec->next_rela = arm_sec->rela;
8344 }
8345
8346 /* If there is no unwind data we can do nothing. */
8347 if (arm_sec->data == NULL)
8348 return FALSE;
8349
8350 /* If the offset is invalid then fail. */
8351 if (/* PR 21343 *//* PR 18879 */
8352 sec->sh_size < 4
8353 || word_offset > (sec->sh_size - 4)
8354 || ((bfd_signed_vma) word_offset) < 0)
8355 return FALSE;
8356
8357 /* Get the word at the required offset. */
8358 word = byte_get (arm_sec->data + word_offset, 4);
8359
8360 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8361 if (arm_sec->rela == NULL)
8362 {
8363 * wordp = word;
8364 return TRUE;
8365 }
8366
8367 /* Look through the relocs to find the one that applies to the provided offset. */
8368 wrapped = FALSE;
8369 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8370 {
8371 bfd_vma prelval, offset;
8372
8373 if (rp->r_offset > word_offset && !wrapped)
8374 {
8375 rp = arm_sec->rela;
8376 wrapped = TRUE;
8377 }
8378 if (rp->r_offset > word_offset)
8379 break;
8380
8381 if (rp->r_offset & 3)
8382 {
8383 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8384 (unsigned long) rp->r_offset);
8385 continue;
8386 }
8387
8388 if (rp->r_offset < word_offset)
8389 continue;
8390
8391 /* PR 17531: file: 027-161405-0.004 */
8392 if (aux->symtab == NULL)
8393 continue;
8394
8395 if (arm_sec->rel_type == SHT_REL)
8396 {
8397 offset = word & 0x7fffffff;
8398 if (offset & 0x40000000)
8399 offset |= ~ (bfd_vma) 0x7fffffff;
8400 }
8401 else if (arm_sec->rel_type == SHT_RELA)
8402 offset = rp->r_addend;
8403 else
8404 {
8405 error (_("Unknown section relocation type %d encountered\n"),
8406 arm_sec->rel_type);
8407 break;
8408 }
8409
8410 /* PR 17531 file: 027-1241568-0.004. */
8411 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8412 {
8413 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8414 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8415 break;
8416 }
8417
8418 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8419 offset += sym->st_value;
8420 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8421
8422 /* Check that we are processing the expected reloc type. */
8423 if (filedata->file_header.e_machine == EM_ARM)
8424 {
8425 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8426 if (relname == NULL)
8427 {
8428 warn (_("Skipping unknown ARM relocation type: %d\n"),
8429 (int) ELF32_R_TYPE (rp->r_info));
8430 continue;
8431 }
8432
8433 if (streq (relname, "R_ARM_NONE"))
8434 continue;
8435
8436 if (! streq (relname, "R_ARM_PREL31"))
8437 {
8438 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8439 continue;
8440 }
8441 }
8442 else if (filedata->file_header.e_machine == EM_TI_C6000)
8443 {
8444 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8445 if (relname == NULL)
8446 {
8447 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8448 (int) ELF32_R_TYPE (rp->r_info));
8449 continue;
8450 }
8451
8452 if (streq (relname, "R_C6000_NONE"))
8453 continue;
8454
8455 if (! streq (relname, "R_C6000_PREL31"))
8456 {
8457 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8458 continue;
8459 }
8460
8461 prelval >>= 1;
8462 }
8463 else
8464 {
8465 /* This function currently only supports ARM and TI unwinders. */
8466 warn (_("Only TI and ARM unwinders are currently supported\n"));
8467 break;
8468 }
8469
8470 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8471 addr->section = sym->st_shndx;
8472 addr->offset = offset;
8473
8474 if (sym_name)
8475 * sym_name = sym->st_name;
8476 break;
8477 }
8478
8479 *wordp = word;
8480 arm_sec->next_rela = rp;
8481
8482 return TRUE;
8483}
8484
8485static const char *tic6x_unwind_regnames[16] =
8486{
8487 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8488 "A14", "A13", "A12", "A11", "A10",
8489 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8490};
8491
8492static void
8493decode_tic6x_unwind_regmask (unsigned int mask)
8494{
8495 int i;
8496
8497 for (i = 12; mask; mask >>= 1, i--)
8498 {
8499 if (mask & 1)
8500 {
8501 fputs (tic6x_unwind_regnames[i], stdout);
8502 if (mask > 1)
8503 fputs (", ", stdout);
8504 }
8505 }
8506}
8507
8508#define ADVANCE \
8509 if (remaining == 0 && more_words) \
8510 { \
8511 data_offset += 4; \
8512 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8513 data_offset, & word, & addr, NULL)) \
8514 return FALSE; \
8515 remaining = 4; \
8516 more_words--; \
8517 } \
8518
8519#define GET_OP(OP) \
8520 ADVANCE; \
8521 if (remaining) \
8522 { \
8523 remaining--; \
8524 (OP) = word >> 24; \
8525 word <<= 8; \
8526 } \
8527 else \
8528 { \
8529 printf (_("[Truncated opcode]\n")); \
8530 return FALSE; \
8531 } \
8532 printf ("0x%02x ", OP)
8533
8534static bfd_boolean
8535decode_arm_unwind_bytecode (Filedata * filedata,
8536 struct arm_unw_aux_info * aux,
8537 unsigned int word,
8538 unsigned int remaining,
8539 unsigned int more_words,
8540 bfd_vma data_offset,
8541 Elf_Internal_Shdr * data_sec,
8542 struct arm_section * data_arm_sec)
8543{
8544 struct absaddr addr;
8545 bfd_boolean res = TRUE;
8546
8547 /* Decode the unwinding instructions. */
8548 while (1)
8549 {
8550 unsigned int op, op2;
8551
8552 ADVANCE;
8553 if (remaining == 0)
8554 break;
8555 remaining--;
8556 op = word >> 24;
8557 word <<= 8;
8558
8559 printf (" 0x%02x ", op);
8560
8561 if ((op & 0xc0) == 0x00)
8562 {
8563 int offset = ((op & 0x3f) << 2) + 4;
8564
8565 printf (" vsp = vsp + %d", offset);
8566 }
8567 else if ((op & 0xc0) == 0x40)
8568 {
8569 int offset = ((op & 0x3f) << 2) + 4;
8570
8571 printf (" vsp = vsp - %d", offset);
8572 }
8573 else if ((op & 0xf0) == 0x80)
8574 {
8575 GET_OP (op2);
8576 if (op == 0x80 && op2 == 0)
8577 printf (_("Refuse to unwind"));
8578 else
8579 {
8580 unsigned int mask = ((op & 0x0f) << 8) | op2;
8581 bfd_boolean first = TRUE;
8582 int i;
8583
8584 printf ("pop {");
8585 for (i = 0; i < 12; i++)
8586 if (mask & (1 << i))
8587 {
8588 if (first)
8589 first = FALSE;
8590 else
8591 printf (", ");
8592 printf ("r%d", 4 + i);
8593 }
8594 printf ("}");
8595 }
8596 }
8597 else if ((op & 0xf0) == 0x90)
8598 {
8599 if (op == 0x9d || op == 0x9f)
8600 printf (_(" [Reserved]"));
8601 else
8602 printf (" vsp = r%d", op & 0x0f);
8603 }
8604 else if ((op & 0xf0) == 0xa0)
8605 {
8606 int end = 4 + (op & 0x07);
8607 bfd_boolean first = TRUE;
8608 int i;
8609
8610 printf (" pop {");
8611 for (i = 4; i <= end; i++)
8612 {
8613 if (first)
8614 first = FALSE;
8615 else
8616 printf (", ");
8617 printf ("r%d", i);
8618 }
8619 if (op & 0x08)
8620 {
8621 if (!first)
8622 printf (", ");
8623 printf ("r14");
8624 }
8625 printf ("}");
8626 }
8627 else if (op == 0xb0)
8628 printf (_(" finish"));
8629 else if (op == 0xb1)
8630 {
8631 GET_OP (op2);
8632 if (op2 == 0 || (op2 & 0xf0) != 0)
8633 printf (_("[Spare]"));
8634 else
8635 {
8636 unsigned int mask = op2 & 0x0f;
8637 bfd_boolean first = TRUE;
8638 int i;
8639
8640 printf ("pop {");
8641 for (i = 0; i < 12; i++)
8642 if (mask & (1 << i))
8643 {
8644 if (first)
8645 first = FALSE;
8646 else
8647 printf (", ");
8648 printf ("r%d", i);
8649 }
8650 printf ("}");
8651 }
8652 }
8653 else if (op == 0xb2)
8654 {
8655 unsigned char buf[9];
8656 unsigned int i, len;
8657 unsigned long offset;
8658
8659 for (i = 0; i < sizeof (buf); i++)
8660 {
8661 GET_OP (buf[i]);
8662 if ((buf[i] & 0x80) == 0)
8663 break;
8664 }
8665 if (i == sizeof (buf))
8666 {
8667 error (_("corrupt change to vsp"));
8668 res = FALSE;
8669 }
8670 else
8671 {
8672 offset = read_uleb128 (buf, &len, buf + i + 1);
8673 assert (len == i + 1);
8674 offset = offset * 4 + 0x204;
8675 printf ("vsp = vsp + %ld", offset);
8676 }
8677 }
8678 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8679 {
8680 unsigned int first, last;
8681
8682 GET_OP (op2);
8683 first = op2 >> 4;
8684 last = op2 & 0x0f;
8685 if (op == 0xc8)
8686 first = first + 16;
8687 printf ("pop {D%d", first);
8688 if (last)
8689 printf ("-D%d", first + last);
8690 printf ("}");
8691 }
8692 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8693 {
8694 unsigned int count = op & 0x07;
8695
8696 printf ("pop {D8");
8697 if (count)
8698 printf ("-D%d", 8 + count);
8699 printf ("}");
8700 }
8701 else if (op >= 0xc0 && op <= 0xc5)
8702 {
8703 unsigned int count = op & 0x07;
8704
8705 printf (" pop {wR10");
8706 if (count)
8707 printf ("-wR%d", 10 + count);
8708 printf ("}");
8709 }
8710 else if (op == 0xc6)
8711 {
8712 unsigned int first, last;
8713
8714 GET_OP (op2);
8715 first = op2 >> 4;
8716 last = op2 & 0x0f;
8717 printf ("pop {wR%d", first);
8718 if (last)
8719 printf ("-wR%d", first + last);
8720 printf ("}");
8721 }
8722 else if (op == 0xc7)
8723 {
8724 GET_OP (op2);
8725 if (op2 == 0 || (op2 & 0xf0) != 0)
8726 printf (_("[Spare]"));
8727 else
8728 {
8729 unsigned int mask = op2 & 0x0f;
8730 bfd_boolean first = TRUE;
8731 int i;
8732
8733 printf ("pop {");
8734 for (i = 0; i < 4; i++)
8735 if (mask & (1 << i))
8736 {
8737 if (first)
8738 first = FALSE;
8739 else
8740 printf (", ");
8741 printf ("wCGR%d", i);
8742 }
8743 printf ("}");
8744 }
8745 }
8746 else
8747 {
8748 printf (_(" [unsupported opcode]"));
8749 res = FALSE;
8750 }
8751
8752 printf ("\n");
8753 }
8754
8755 return res;
8756}
8757
8758static bfd_boolean
8759decode_tic6x_unwind_bytecode (Filedata * filedata,
8760 struct arm_unw_aux_info * aux,
8761 unsigned int word,
8762 unsigned int remaining,
8763 unsigned int more_words,
8764 bfd_vma data_offset,
8765 Elf_Internal_Shdr * data_sec,
8766 struct arm_section * data_arm_sec)
8767{
8768 struct absaddr addr;
8769
8770 /* Decode the unwinding instructions. */
8771 while (1)
8772 {
8773 unsigned int op, op2;
8774
8775 ADVANCE;
8776 if (remaining == 0)
8777 break;
8778 remaining--;
8779 op = word >> 24;
8780 word <<= 8;
8781
8782 printf (" 0x%02x ", op);
8783
8784 if ((op & 0xc0) == 0x00)
8785 {
8786 int offset = ((op & 0x3f) << 3) + 8;
8787 printf (" sp = sp + %d", offset);
8788 }
8789 else if ((op & 0xc0) == 0x80)
8790 {
8791 GET_OP (op2);
8792 if (op == 0x80 && op2 == 0)
8793 printf (_("Refuse to unwind"));
8794 else
8795 {
8796 unsigned int mask = ((op & 0x1f) << 8) | op2;
8797 if (op & 0x20)
8798 printf ("pop compact {");
8799 else
8800 printf ("pop {");
8801
8802 decode_tic6x_unwind_regmask (mask);
8803 printf("}");
8804 }
8805 }
8806 else if ((op & 0xf0) == 0xc0)
8807 {
8808 unsigned int reg;
8809 unsigned int nregs;
8810 unsigned int i;
8811 const char *name;
8812 struct
8813 {
8814 unsigned int offset;
8815 unsigned int reg;
8816 } regpos[16];
8817
8818 /* Scan entire instruction first so that GET_OP output is not
8819 interleaved with disassembly. */
8820 nregs = 0;
8821 for (i = 0; nregs < (op & 0xf); i++)
8822 {
8823 GET_OP (op2);
8824 reg = op2 >> 4;
8825 if (reg != 0xf)
8826 {
8827 regpos[nregs].offset = i * 2;
8828 regpos[nregs].reg = reg;
8829 nregs++;
8830 }
8831
8832 reg = op2 & 0xf;
8833 if (reg != 0xf)
8834 {
8835 regpos[nregs].offset = i * 2 + 1;
8836 regpos[nregs].reg = reg;
8837 nregs++;
8838 }
8839 }
8840
8841 printf (_("pop frame {"));
8842 reg = nregs - 1;
8843 for (i = i * 2; i > 0; i--)
8844 {
8845 if (regpos[reg].offset == i - 1)
8846 {
8847 name = tic6x_unwind_regnames[regpos[reg].reg];
8848 if (reg > 0)
8849 reg--;
8850 }
8851 else
8852 name = _("[pad]");
8853
8854 fputs (name, stdout);
8855 if (i > 1)
8856 printf (", ");
8857 }
8858
8859 printf ("}");
8860 }
8861 else if (op == 0xd0)
8862 printf (" MOV FP, SP");
8863 else if (op == 0xd1)
8864 printf (" __c6xabi_pop_rts");
8865 else if (op == 0xd2)
8866 {
8867 unsigned char buf[9];
8868 unsigned int i, len;
8869 unsigned long offset;
8870
8871 for (i = 0; i < sizeof (buf); i++)
8872 {
8873 GET_OP (buf[i]);
8874 if ((buf[i] & 0x80) == 0)
8875 break;
8876 }
8877 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8878 if (i == sizeof (buf))
8879 {
8880 warn (_("Corrupt stack pointer adjustment detected\n"));
8881 return FALSE;
8882 }
8883
8884 offset = read_uleb128 (buf, &len, buf + i + 1);
8885 assert (len == i + 1);
8886 offset = offset * 8 + 0x408;
8887 printf (_("sp = sp + %ld"), offset);
8888 }
8889 else if ((op & 0xf0) == 0xe0)
8890 {
8891 if ((op & 0x0f) == 7)
8892 printf (" RETURN");
8893 else
8894 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8895 }
8896 else
8897 {
8898 printf (_(" [unsupported opcode]"));
8899 }
8900 putchar ('\n');
8901 }
8902
8903 return TRUE;
8904}
8905
8906static bfd_vma
8907arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8908{
8909 bfd_vma offset;
8910
8911 offset = word & 0x7fffffff;
8912 if (offset & 0x40000000)
8913 offset |= ~ (bfd_vma) 0x7fffffff;
8914
8915 if (filedata->file_header.e_machine == EM_TI_C6000)
8916 offset <<= 1;
8917
8918 return offset + where;
8919}
8920
8921static bfd_boolean
8922decode_arm_unwind (Filedata * filedata,
8923 struct arm_unw_aux_info * aux,
8924 unsigned int word,
8925 unsigned int remaining,
8926 bfd_vma data_offset,
8927 Elf_Internal_Shdr * data_sec,
8928 struct arm_section * data_arm_sec)
8929{
8930 int per_index;
8931 unsigned int more_words = 0;
8932 struct absaddr addr;
8933 bfd_vma sym_name = (bfd_vma) -1;
8934 bfd_boolean res = TRUE;
8935
8936 if (remaining == 0)
8937 {
8938 /* Fetch the first word.
8939 Note - when decoding an object file the address extracted
8940 here will always be 0. So we also pass in the sym_name
8941 parameter so that we can find the symbol associated with
8942 the personality routine. */
8943 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8944 & word, & addr, & sym_name))
8945 return FALSE;
8946
8947 remaining = 4;
8948 }
8949
8950 if ((word & 0x80000000) == 0)
8951 {
8952 /* Expand prel31 for personality routine. */
8953 bfd_vma fn;
8954 const char *procname;
8955
8956 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8957 printf (_(" Personality routine: "));
8958 if (fn == 0
8959 && addr.section == SHN_UNDEF && addr.offset == 0
8960 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8961 {
8962 procname = aux->strtab + sym_name;
8963 print_vma (fn, PREFIX_HEX);
8964 if (procname)
8965 {
8966 fputs (" <", stdout);
8967 fputs (procname, stdout);
8968 fputc ('>', stdout);
8969 }
8970 }
8971 else
8972 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8973 fputc ('\n', stdout);
8974
8975 /* The GCC personality routines use the standard compact
8976 encoding, starting with one byte giving the number of
8977 words. */
8978 if (procname != NULL
8979 && (const_strneq (procname, "__gcc_personality_v0")
8980 || const_strneq (procname, "__gxx_personality_v0")
8981 || const_strneq (procname, "__gcj_personality_v0")
8982 || const_strneq (procname, "__gnu_objc_personality_v0")))
8983 {
8984 remaining = 0;
8985 more_words = 1;
8986 ADVANCE;
8987 if (!remaining)
8988 {
8989 printf (_(" [Truncated data]\n"));
8990 return FALSE;
8991 }
8992 more_words = word >> 24;
8993 word <<= 8;
8994 remaining--;
8995 per_index = -1;
8996 }
8997 else
8998 return TRUE;
8999 }
9000 else
9001 {
9002 /* ARM EHABI Section 6.3:
9003
9004 An exception-handling table entry for the compact model looks like:
9005
9006 31 30-28 27-24 23-0
9007 -- ----- ----- ----
9008 1 0 index Data for personalityRoutine[index] */
9009
9010 if (filedata->file_header.e_machine == EM_ARM
9011 && (word & 0x70000000))
9012 {
9013 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9014 res = FALSE;
9015 }
9016
9017 per_index = (word >> 24) & 0x7f;
9018 printf (_(" Compact model index: %d\n"), per_index);
9019 if (per_index == 0)
9020 {
9021 more_words = 0;
9022 word <<= 8;
9023 remaining--;
9024 }
9025 else if (per_index < 3)
9026 {
9027 more_words = (word >> 16) & 0xff;
9028 word <<= 16;
9029 remaining -= 2;
9030 }
9031 }
9032
9033 switch (filedata->file_header.e_machine)
9034 {
9035 case EM_ARM:
9036 if (per_index < 3)
9037 {
9038 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9039 data_offset, data_sec, data_arm_sec))
9040 res = FALSE;
9041 }
9042 else
9043 {
9044 warn (_("Unknown ARM compact model index encountered\n"));
9045 printf (_(" [reserved]\n"));
9046 res = FALSE;
9047 }
9048 break;
9049
9050 case EM_TI_C6000:
9051 if (per_index < 3)
9052 {
9053 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9054 data_offset, data_sec, data_arm_sec))
9055 res = FALSE;
9056 }
9057 else if (per_index < 5)
9058 {
9059 if (((word >> 17) & 0x7f) == 0x7f)
9060 printf (_(" Restore stack from frame pointer\n"));
9061 else
9062 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9063 printf (_(" Registers restored: "));
9064 if (per_index == 4)
9065 printf (" (compact) ");
9066 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9067 putchar ('\n');
9068 printf (_(" Return register: %s\n"),
9069 tic6x_unwind_regnames[word & 0xf]);
9070 }
9071 else
9072 printf (_(" [reserved (%d)]\n"), per_index);
9073 break;
9074
9075 default:
9076 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9077 filedata->file_header.e_machine);
9078 res = FALSE;
9079 }
9080
9081 /* Decode the descriptors. Not implemented. */
9082
9083 return res;
9084}
9085
9086static bfd_boolean
9087dump_arm_unwind (Filedata * filedata,
9088 struct arm_unw_aux_info * aux,
9089 Elf_Internal_Shdr * exidx_sec)
9090{
9091 struct arm_section exidx_arm_sec, extab_arm_sec;
9092 unsigned int i, exidx_len;
9093 unsigned long j, nfuns;
9094 bfd_boolean res = TRUE;
9095
9096 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9097 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9098 exidx_len = exidx_sec->sh_size / 8;
9099
9100 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9101 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9102 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9103 aux->funtab[nfuns++] = aux->symtab[j];
9104 aux->nfuns = nfuns;
9105 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9106
9107 for (i = 0; i < exidx_len; i++)
9108 {
9109 unsigned int exidx_fn, exidx_entry;
9110 struct absaddr fn_addr, entry_addr;
9111 bfd_vma fn;
9112
9113 fputc ('\n', stdout);
9114
9115 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9116 8 * i, & exidx_fn, & fn_addr, NULL)
9117 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9118 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9119 {
9120 free (aux->funtab);
9121 arm_free_section (& exidx_arm_sec);
9122 arm_free_section (& extab_arm_sec);
9123 return FALSE;
9124 }
9125
9126 /* ARM EHABI, Section 5:
9127 An index table entry consists of 2 words.
9128 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9129 if (exidx_fn & 0x80000000)
9130 {
9131 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9132 res = FALSE;
9133 }
9134
9135 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9136
9137 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9138 fputs (": ", stdout);
9139
9140 if (exidx_entry == 1)
9141 {
9142 print_vma (exidx_entry, PREFIX_HEX);
9143 fputs (" [cantunwind]\n", stdout);
9144 }
9145 else if (exidx_entry & 0x80000000)
9146 {
9147 print_vma (exidx_entry, PREFIX_HEX);
9148 fputc ('\n', stdout);
9149 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9150 }
9151 else
9152 {
9153 bfd_vma table, table_offset = 0;
9154 Elf_Internal_Shdr *table_sec;
9155
9156 fputs ("@", stdout);
9157 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9158 print_vma (table, PREFIX_HEX);
9159 printf ("\n");
9160
9161 /* Locate the matching .ARM.extab. */
9162 if (entry_addr.section != SHN_UNDEF
9163 && entry_addr.section < filedata->file_header.e_shnum)
9164 {
9165 table_sec = filedata->section_headers + entry_addr.section;
9166 table_offset = entry_addr.offset;
9167 /* PR 18879 */
9168 if (table_offset > table_sec->sh_size
9169 || ((bfd_signed_vma) table_offset) < 0)
9170 {
9171 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9172 (unsigned long) table_offset,
9173 printable_section_name (filedata, table_sec));
9174 res = FALSE;
9175 continue;
9176 }
9177 }
9178 else
9179 {
9180 table_sec = find_section_by_address (filedata, table);
9181 if (table_sec != NULL)
9182 table_offset = table - table_sec->sh_addr;
9183 }
9184
9185 if (table_sec == NULL)
9186 {
9187 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9188 (unsigned long) table);
9189 res = FALSE;
9190 continue;
9191 }
9192
9193 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9194 &extab_arm_sec))
9195 res = FALSE;
9196 }
9197 }
9198
9199 printf ("\n");
9200
9201 free (aux->funtab);
9202 arm_free_section (&exidx_arm_sec);
9203 arm_free_section (&extab_arm_sec);
9204
9205 return res;
9206}
9207
9208/* Used for both ARM and C6X unwinding tables. */
9209
9210static bfd_boolean
9211arm_process_unwind (Filedata * filedata)
9212{
9213 struct arm_unw_aux_info aux;
9214 Elf_Internal_Shdr *unwsec = NULL;
9215 Elf_Internal_Shdr *strsec;
9216 Elf_Internal_Shdr *sec;
9217 unsigned long i;
9218 unsigned int sec_type;
9219 bfd_boolean res = TRUE;
9220
9221 switch (filedata->file_header.e_machine)
9222 {
9223 case EM_ARM:
9224 sec_type = SHT_ARM_EXIDX;
9225 break;
9226
9227 case EM_TI_C6000:
9228 sec_type = SHT_C6000_UNWIND;
9229 break;
9230
9231 default:
9232 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9233 filedata->file_header.e_machine);
9234 return FALSE;
9235 }
9236
9237 if (filedata->string_table == NULL)
9238 return FALSE;
9239
9240 memset (& aux, 0, sizeof (aux));
9241 aux.filedata = filedata;
9242
9243 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9244 {
9245 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9246 {
9247 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9248
9249 strsec = filedata->section_headers + sec->sh_link;
9250
9251 /* PR binutils/17531 file: 011-12666-0.004. */
9252 if (aux.strtab != NULL)
9253 {
9254 error (_("Multiple string tables found in file.\n"));
9255 free (aux.strtab);
9256 res = FALSE;
9257 }
9258 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9259 1, strsec->sh_size, _("string table"));
9260 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9261 }
9262 else if (sec->sh_type == sec_type)
9263 unwsec = sec;
9264 }
9265
9266 if (unwsec == NULL)
9267 printf (_("\nThere are no unwind sections in this file.\n"));
9268 else
9269 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9270 {
9271 if (sec->sh_type == sec_type)
9272 {
9273 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9274 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9275 "contains %lu entry:\n",
9276 "\nUnwind section '%s' at offset 0x%lx "
9277 "contains %lu entries:\n",
9278 num_unwind),
9279 printable_section_name (filedata, sec),
9280 (unsigned long) sec->sh_offset,
9281 num_unwind);
9282
9283 if (! dump_arm_unwind (filedata, &aux, sec))
9284 res = FALSE;
9285 }
9286 }
9287
9288 if (aux.symtab)
9289 free (aux.symtab);
9290 if (aux.strtab)
9291 free ((char *) aux.strtab);
9292
9293 return res;
9294}
9295
9296static bfd_boolean
9297process_unwind (Filedata * filedata)
9298{
9299 struct unwind_handler
9300 {
9301 unsigned int machtype;
9302 bfd_boolean (* handler)(Filedata *);
9303 } handlers[] =
9304 {
9305 { EM_ARM, arm_process_unwind },
9306 { EM_IA_64, ia64_process_unwind },
9307 { EM_PARISC, hppa_process_unwind },
9308 { EM_TI_C6000, arm_process_unwind },
9309 { 0, NULL }
9310 };
9311 int i;
9312
9313 if (!do_unwind)
9314 return TRUE;
9315
9316 for (i = 0; handlers[i].handler != NULL; i++)
9317 if (filedata->file_header.e_machine == handlers[i].machtype)
9318 return handlers[i].handler (filedata);
9319
9320 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9321 get_machine_name (filedata->file_header.e_machine));
9322 return TRUE;
9323}
9324
9325static void
9326dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9327{
9328 switch (entry->d_tag)
9329 {
9330 case DT_MIPS_FLAGS:
9331 if (entry->d_un.d_val == 0)
9332 printf (_("NONE"));
9333 else
9334 {
9335 static const char * opts[] =
9336 {
9337 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9338 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9339 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9340 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9341 "RLD_ORDER_SAFE"
9342 };
9343 unsigned int cnt;
9344 bfd_boolean first = TRUE;
9345
9346 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9347 if (entry->d_un.d_val & (1 << cnt))
9348 {
9349 printf ("%s%s", first ? "" : " ", opts[cnt]);
9350 first = FALSE;
9351 }
9352 }
9353 break;
9354
9355 case DT_MIPS_IVERSION:
9356 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9357 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9358 else
9359 {
9360 char buf[40];
9361 sprintf_vma (buf, entry->d_un.d_ptr);
9362 /* Note: coded this way so that there is a single string for translation. */
9363 printf (_("<corrupt: %s>"), buf);
9364 }
9365 break;
9366
9367 case DT_MIPS_TIME_STAMP:
9368 {
9369 char timebuf[128];
9370 struct tm * tmp;
9371 time_t atime = entry->d_un.d_val;
9372
9373 tmp = gmtime (&atime);
9374 /* PR 17531: file: 6accc532. */
9375 if (tmp == NULL)
9376 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9377 else
9378 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9379 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9380 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9381 printf (_("Time Stamp: %s"), timebuf);
9382 }
9383 break;
9384
9385 case DT_MIPS_RLD_VERSION:
9386 case DT_MIPS_LOCAL_GOTNO:
9387 case DT_MIPS_CONFLICTNO:
9388 case DT_MIPS_LIBLISTNO:
9389 case DT_MIPS_SYMTABNO:
9390 case DT_MIPS_UNREFEXTNO:
9391 case DT_MIPS_HIPAGENO:
9392 case DT_MIPS_DELTA_CLASS_NO:
9393 case DT_MIPS_DELTA_INSTANCE_NO:
9394 case DT_MIPS_DELTA_RELOC_NO:
9395 case DT_MIPS_DELTA_SYM_NO:
9396 case DT_MIPS_DELTA_CLASSSYM_NO:
9397 case DT_MIPS_COMPACT_SIZE:
9398 print_vma (entry->d_un.d_val, DEC);
9399 break;
9400
9401 default:
9402 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9403 }
9404 putchar ('\n');
9405}
9406
9407static void
9408dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9409{
9410 switch (entry->d_tag)
9411 {
9412 case DT_HP_DLD_FLAGS:
9413 {
9414 static struct
9415 {
9416 long int bit;
9417 const char * str;
9418 }
9419 flags[] =
9420 {
9421 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9422 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9423 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9424 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9425 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9426 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9427 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9428 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9429 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9430 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9431 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9432 { DT_HP_GST, "HP_GST" },
9433 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9434 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9435 { DT_HP_NODELETE, "HP_NODELETE" },
9436 { DT_HP_GROUP, "HP_GROUP" },
9437 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9438 };
9439 bfd_boolean first = TRUE;
9440 size_t cnt;
9441 bfd_vma val = entry->d_un.d_val;
9442
9443 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9444 if (val & flags[cnt].bit)
9445 {
9446 if (! first)
9447 putchar (' ');
9448 fputs (flags[cnt].str, stdout);
9449 first = FALSE;
9450 val ^= flags[cnt].bit;
9451 }
9452
9453 if (val != 0 || first)
9454 {
9455 if (! first)
9456 putchar (' ');
9457 print_vma (val, HEX);
9458 }
9459 }
9460 break;
9461
9462 default:
9463 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9464 break;
9465 }
9466 putchar ('\n');
9467}
9468
9469#ifdef BFD64
9470
9471/* VMS vs Unix time offset and factor. */
9472
9473#define VMS_EPOCH_OFFSET 35067168000000000LL
9474#define VMS_GRANULARITY_FACTOR 10000000
9475
9476/* Display a VMS time in a human readable format. */
9477
9478static void
9479print_vms_time (bfd_int64_t vmstime)
9480{
9481 struct tm *tm;
9482 time_t unxtime;
9483
9484 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9485 tm = gmtime (&unxtime);
9486 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9487 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9488 tm->tm_hour, tm->tm_min, tm->tm_sec);
9489}
9490#endif /* BFD64 */
9491
9492static void
9493dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9494{
9495 switch (entry->d_tag)
9496 {
9497 case DT_IA_64_PLT_RESERVE:
9498 /* First 3 slots reserved. */
9499 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9500 printf (" -- ");
9501 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9502 break;
9503
9504 case DT_IA_64_VMS_LINKTIME:
9505#ifdef BFD64
9506 print_vms_time (entry->d_un.d_val);
9507#endif
9508 break;
9509
9510 case DT_IA_64_VMS_LNKFLAGS:
9511 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9512 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9513 printf (" CALL_DEBUG");
9514 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9515 printf (" NOP0BUFS");
9516 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9517 printf (" P0IMAGE");
9518 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9519 printf (" MKTHREADS");
9520 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9521 printf (" UPCALLS");
9522 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9523 printf (" IMGSTA");
9524 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9525 printf (" INITIALIZE");
9526 if (entry->d_un.d_val & VMS_LF_MAIN)
9527 printf (" MAIN");
9528 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9529 printf (" EXE_INIT");
9530 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9531 printf (" TBK_IN_IMG");
9532 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9533 printf (" DBG_IN_IMG");
9534 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9535 printf (" TBK_IN_DSF");
9536 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9537 printf (" DBG_IN_DSF");
9538 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9539 printf (" SIGNATURES");
9540 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9541 printf (" REL_SEG_OFF");
9542 break;
9543
9544 default:
9545 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9546 break;
9547 }
9548 putchar ('\n');
9549}
9550
9551static bfd_boolean
9552get_32bit_dynamic_section (Filedata * filedata)
9553{
9554 Elf32_External_Dyn * edyn;
9555 Elf32_External_Dyn * ext;
9556 Elf_Internal_Dyn * entry;
9557
9558 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9559 dynamic_size, _("dynamic section"));
9560 if (!edyn)
9561 return FALSE;
9562
9563 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9564 might not have the luxury of section headers. Look for the DT_NULL
9565 terminator to determine the number of entries. */
9566 for (ext = edyn, dynamic_nent = 0;
9567 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9568 ext++)
9569 {
9570 dynamic_nent++;
9571 if (BYTE_GET (ext->d_tag) == DT_NULL)
9572 break;
9573 }
9574
9575 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9576 sizeof (* entry));
9577 if (dynamic_section == NULL)
9578 {
9579 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9580 (unsigned long) dynamic_nent);
9581 free (edyn);
9582 return FALSE;
9583 }
9584
9585 for (ext = edyn, entry = dynamic_section;
9586 entry < dynamic_section + dynamic_nent;
9587 ext++, entry++)
9588 {
9589 entry->d_tag = BYTE_GET (ext->d_tag);
9590 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9591 }
9592
9593 free (edyn);
9594
9595 return TRUE;
9596}
9597
9598static bfd_boolean
9599get_64bit_dynamic_section (Filedata * filedata)
9600{
9601 Elf64_External_Dyn * edyn;
9602 Elf64_External_Dyn * ext;
9603 Elf_Internal_Dyn * entry;
9604
9605 /* Read in the data. */
9606 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9607 dynamic_size, _("dynamic section"));
9608 if (!edyn)
9609 return FALSE;
9610
9611 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9612 might not have the luxury of section headers. Look for the DT_NULL
9613 terminator to determine the number of entries. */
9614 for (ext = edyn, dynamic_nent = 0;
9615 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9616 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9617 ext++)
9618 {
9619 dynamic_nent++;
9620 if (BYTE_GET (ext->d_tag) == DT_NULL)
9621 break;
9622 }
9623
9624 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9625 sizeof (* entry));
9626 if (dynamic_section == NULL)
9627 {
9628 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9629 (unsigned long) dynamic_nent);
9630 free (edyn);
9631 return FALSE;
9632 }
9633
9634 /* Convert from external to internal formats. */
9635 for (ext = edyn, entry = dynamic_section;
9636 entry < dynamic_section + dynamic_nent;
9637 ext++, entry++)
9638 {
9639 entry->d_tag = BYTE_GET (ext->d_tag);
9640 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9641 }
9642
9643 free (edyn);
9644
9645 return TRUE;
9646}
9647
9648static void
9649print_dynamic_flags (bfd_vma flags)
9650{
9651 bfd_boolean first = TRUE;
9652
9653 while (flags)
9654 {
9655 bfd_vma flag;
9656
9657 flag = flags & - flags;
9658 flags &= ~ flag;
9659
9660 if (first)
9661 first = FALSE;
9662 else
9663 putc (' ', stdout);
9664
9665 switch (flag)
9666 {
9667 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9668 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9669 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9670 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9671 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9672 default: fputs (_("unknown"), stdout); break;
9673 }
9674 }
9675 puts ("");
9676}
9677
9678/* Parse and display the contents of the dynamic section. */
9679
9680static bfd_boolean
9681process_dynamic_section (Filedata * filedata)
9682{
9683 Elf_Internal_Dyn * entry;
9684
9685 if (dynamic_size == 0)
9686 {
9687 if (do_dynamic)
9688 printf (_("\nThere is no dynamic section in this file.\n"));
9689
9690 return TRUE;
9691 }
9692
9693 if (is_32bit_elf)
9694 {
9695 if (! get_32bit_dynamic_section (filedata))
9696 return FALSE;
9697 }
9698 else
9699 {
9700 if (! get_64bit_dynamic_section (filedata))
9701 return FALSE;
9702 }
9703
9704 /* Find the appropriate symbol table. */
9705 if (dynamic_symbols == NULL)
9706 {
9707 for (entry = dynamic_section;
9708 entry < dynamic_section + dynamic_nent;
9709 ++entry)
9710 {
9711 Elf_Internal_Shdr section;
9712
9713 if (entry->d_tag != DT_SYMTAB)
9714 continue;
9715
9716 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9717
9718 /* Since we do not know how big the symbol table is,
9719 we default to reading in the entire file (!) and
9720 processing that. This is overkill, I know, but it
9721 should work. */
9722 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9723 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9724 {
9725 /* See PR 21379 for a reproducer. */
9726 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9727 return FALSE;
9728 }
9729
9730 if (archive_file_offset != 0)
9731 section.sh_size = archive_file_size - section.sh_offset;
9732 else
9733 section.sh_size = filedata->file_size - section.sh_offset;
9734
9735 if (is_32bit_elf)
9736 section.sh_entsize = sizeof (Elf32_External_Sym);
9737 else
9738 section.sh_entsize = sizeof (Elf64_External_Sym);
9739 section.sh_name = filedata->string_table_length;
9740
9741 if (dynamic_symbols != NULL)
9742 {
9743 error (_("Multiple dynamic symbol table sections found\n"));
9744 free (dynamic_symbols);
9745 }
9746 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9747 if (num_dynamic_syms < 1)
9748 {
9749 error (_("Unable to determine the number of symbols to load\n"));
9750 continue;
9751 }
9752 }
9753 }
9754
9755 /* Similarly find a string table. */
9756 if (dynamic_strings == NULL)
9757 {
9758 for (entry = dynamic_section;
9759 entry < dynamic_section + dynamic_nent;
9760 ++entry)
9761 {
9762 unsigned long offset;
9763 long str_tab_len;
9764
9765 if (entry->d_tag != DT_STRTAB)
9766 continue;
9767
9768 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9769
9770 /* Since we do not know how big the string table is,
9771 we default to reading in the entire file (!) and
9772 processing that. This is overkill, I know, but it
9773 should work. */
9774
9775 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9776
9777 if (archive_file_offset != 0)
9778 str_tab_len = archive_file_size - offset;
9779 else
9780 str_tab_len = filedata->file_size - offset;
9781
9782 if (str_tab_len < 1)
9783 {
9784 error
9785 (_("Unable to determine the length of the dynamic string table\n"));
9786 continue;
9787 }
9788
9789 if (dynamic_strings != NULL)
9790 {
9791 error (_("Multiple dynamic string tables found\n"));
9792 free (dynamic_strings);
9793 }
9794
9795 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9796 str_tab_len,
9797 _("dynamic string table"));
9798 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9799 }
9800 }
9801
9802 /* And find the syminfo section if available. */
9803 if (dynamic_syminfo == NULL)
9804 {
9805 unsigned long syminsz = 0;
9806
9807 for (entry = dynamic_section;
9808 entry < dynamic_section + dynamic_nent;
9809 ++entry)
9810 {
9811 if (entry->d_tag == DT_SYMINENT)
9812 {
9813 /* Note: these braces are necessary to avoid a syntax
9814 error from the SunOS4 C compiler. */
9815 /* PR binutils/17531: A corrupt file can trigger this test.
9816 So do not use an assert, instead generate an error message. */
9817 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9818 error (_("Bad value (%d) for SYMINENT entry\n"),
9819 (int) entry->d_un.d_val);
9820 }
9821 else if (entry->d_tag == DT_SYMINSZ)
9822 syminsz = entry->d_un.d_val;
9823 else if (entry->d_tag == DT_SYMINFO)
9824 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9825 syminsz);
9826 }
9827
9828 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9829 {
9830 Elf_External_Syminfo * extsyminfo;
9831 Elf_External_Syminfo * extsym;
9832 Elf_Internal_Syminfo * syminfo;
9833
9834 /* There is a syminfo section. Read the data. */
9835 extsyminfo = (Elf_External_Syminfo *)
9836 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9837 _("symbol information"));
9838 if (!extsyminfo)
9839 return FALSE;
9840
9841 if (dynamic_syminfo != NULL)
9842 {
9843 error (_("Multiple dynamic symbol information sections found\n"));
9844 free (dynamic_syminfo);
9845 }
9846 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9847 if (dynamic_syminfo == NULL)
9848 {
9849 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9850 (unsigned long) syminsz);
9851 return FALSE;
9852 }
9853
9854 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9855 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9856 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9857 ++syminfo, ++extsym)
9858 {
9859 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9860 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9861 }
9862
9863 free (extsyminfo);
9864 }
9865 }
9866
9867 if (do_dynamic && dynamic_addr)
9868 printf (ngettext ("\nDynamic section at offset 0x%lx "
9869 "contains %lu entry:\n",
9870 "\nDynamic section at offset 0x%lx "
9871 "contains %lu entries:\n",
9872 dynamic_nent),
9873 dynamic_addr, (unsigned long) dynamic_nent);
9874 if (do_dynamic)
9875 printf (_(" Tag Type Name/Value\n"));
9876
9877 for (entry = dynamic_section;
9878 entry < dynamic_section + dynamic_nent;
9879 entry++)
9880 {
9881 if (do_dynamic)
9882 {
9883 const char * dtype;
9884
9885 putchar (' ');
9886 print_vma (entry->d_tag, FULL_HEX);
9887 dtype = get_dynamic_type (filedata, entry->d_tag);
9888 printf (" (%s)%*s", dtype,
9889 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9890 }
9891
9892 switch (entry->d_tag)
9893 {
9894 case DT_FLAGS:
9895 if (do_dynamic)
9896 print_dynamic_flags (entry->d_un.d_val);
9897 break;
9898
9899 case DT_AUXILIARY:
9900 case DT_FILTER:
9901 case DT_CONFIG:
9902 case DT_DEPAUDIT:
9903 case DT_AUDIT:
9904 if (do_dynamic)
9905 {
9906 switch (entry->d_tag)
9907 {
9908 case DT_AUXILIARY:
9909 printf (_("Auxiliary library"));
9910 break;
9911
9912 case DT_FILTER:
9913 printf (_("Filter library"));
9914 break;
9915
9916 case DT_CONFIG:
9917 printf (_("Configuration file"));
9918 break;
9919
9920 case DT_DEPAUDIT:
9921 printf (_("Dependency audit library"));
9922 break;
9923
9924 case DT_AUDIT:
9925 printf (_("Audit library"));
9926 break;
9927 }
9928
9929 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9930 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9931 else
9932 {
9933 printf (": ");
9934 print_vma (entry->d_un.d_val, PREFIX_HEX);
9935 putchar ('\n');
9936 }
9937 }
9938 break;
9939
9940 case DT_FEATURE:
9941 if (do_dynamic)
9942 {
9943 printf (_("Flags:"));
9944
9945 if (entry->d_un.d_val == 0)
9946 printf (_(" None\n"));
9947 else
9948 {
9949 unsigned long int val = entry->d_un.d_val;
9950
9951 if (val & DTF_1_PARINIT)
9952 {
9953 printf (" PARINIT");
9954 val ^= DTF_1_PARINIT;
9955 }
9956 if (val & DTF_1_CONFEXP)
9957 {
9958 printf (" CONFEXP");
9959 val ^= DTF_1_CONFEXP;
9960 }
9961 if (val != 0)
9962 printf (" %lx", val);
9963 puts ("");
9964 }
9965 }
9966 break;
9967
9968 case DT_POSFLAG_1:
9969 if (do_dynamic)
9970 {
9971 printf (_("Flags:"));
9972
9973 if (entry->d_un.d_val == 0)
9974 printf (_(" None\n"));
9975 else
9976 {
9977 unsigned long int val = entry->d_un.d_val;
9978
9979 if (val & DF_P1_LAZYLOAD)
9980 {
9981 printf (" LAZYLOAD");
9982 val ^= DF_P1_LAZYLOAD;
9983 }
9984 if (val & DF_P1_GROUPPERM)
9985 {
9986 printf (" GROUPPERM");
9987 val ^= DF_P1_GROUPPERM;
9988 }
9989 if (val != 0)
9990 printf (" %lx", val);
9991 puts ("");
9992 }
9993 }
9994 break;
9995
9996 case DT_FLAGS_1:
9997 if (do_dynamic)
9998 {
9999 printf (_("Flags:"));
10000 if (entry->d_un.d_val == 0)
10001 printf (_(" None\n"));
10002 else
10003 {
10004 unsigned long int val = entry->d_un.d_val;
10005
10006 if (val & DF_1_NOW)
10007 {
10008 printf (" NOW");
10009 val ^= DF_1_NOW;
10010 }
10011 if (val & DF_1_GLOBAL)
10012 {
10013 printf (" GLOBAL");
10014 val ^= DF_1_GLOBAL;
10015 }
10016 if (val & DF_1_GROUP)
10017 {
10018 printf (" GROUP");
10019 val ^= DF_1_GROUP;
10020 }
10021 if (val & DF_1_NODELETE)
10022 {
10023 printf (" NODELETE");
10024 val ^= DF_1_NODELETE;
10025 }
10026 if (val & DF_1_LOADFLTR)
10027 {
10028 printf (" LOADFLTR");
10029 val ^= DF_1_LOADFLTR;
10030 }
10031 if (val & DF_1_INITFIRST)
10032 {
10033 printf (" INITFIRST");
10034 val ^= DF_1_INITFIRST;
10035 }
10036 if (val & DF_1_NOOPEN)
10037 {
10038 printf (" NOOPEN");
10039 val ^= DF_1_NOOPEN;
10040 }
10041 if (val & DF_1_ORIGIN)
10042 {
10043 printf (" ORIGIN");
10044 val ^= DF_1_ORIGIN;
10045 }
10046 if (val & DF_1_DIRECT)
10047 {
10048 printf (" DIRECT");
10049 val ^= DF_1_DIRECT;
10050 }
10051 if (val & DF_1_TRANS)
10052 {
10053 printf (" TRANS");
10054 val ^= DF_1_TRANS;
10055 }
10056 if (val & DF_1_INTERPOSE)
10057 {
10058 printf (" INTERPOSE");
10059 val ^= DF_1_INTERPOSE;
10060 }
10061 if (val & DF_1_NODEFLIB)
10062 {
10063 printf (" NODEFLIB");
10064 val ^= DF_1_NODEFLIB;
10065 }
10066 if (val & DF_1_NODUMP)
10067 {
10068 printf (" NODUMP");
10069 val ^= DF_1_NODUMP;
10070 }
10071 if (val & DF_1_CONFALT)
10072 {
10073 printf (" CONFALT");
10074 val ^= DF_1_CONFALT;
10075 }
10076 if (val & DF_1_ENDFILTEE)
10077 {
10078 printf (" ENDFILTEE");
10079 val ^= DF_1_ENDFILTEE;
10080 }
10081 if (val & DF_1_DISPRELDNE)
10082 {
10083 printf (" DISPRELDNE");
10084 val ^= DF_1_DISPRELDNE;
10085 }
10086 if (val & DF_1_DISPRELPND)
10087 {
10088 printf (" DISPRELPND");
10089 val ^= DF_1_DISPRELPND;
10090 }
10091 if (val & DF_1_NODIRECT)
10092 {
10093 printf (" NODIRECT");
10094 val ^= DF_1_NODIRECT;
10095 }
10096 if (val & DF_1_IGNMULDEF)
10097 {
10098 printf (" IGNMULDEF");
10099 val ^= DF_1_IGNMULDEF;
10100 }
10101 if (val & DF_1_NOKSYMS)
10102 {
10103 printf (" NOKSYMS");
10104 val ^= DF_1_NOKSYMS;
10105 }
10106 if (val & DF_1_NOHDR)
10107 {
10108 printf (" NOHDR");
10109 val ^= DF_1_NOHDR;
10110 }
10111 if (val & DF_1_EDITED)
10112 {
10113 printf (" EDITED");
10114 val ^= DF_1_EDITED;
10115 }
10116 if (val & DF_1_NORELOC)
10117 {
10118 printf (" NORELOC");
10119 val ^= DF_1_NORELOC;
10120 }
10121 if (val & DF_1_SYMINTPOSE)
10122 {
10123 printf (" SYMINTPOSE");
10124 val ^= DF_1_SYMINTPOSE;
10125 }
10126 if (val & DF_1_GLOBAUDIT)
10127 {
10128 printf (" GLOBAUDIT");
10129 val ^= DF_1_GLOBAUDIT;
10130 }
10131 if (val & DF_1_SINGLETON)
10132 {
10133 printf (" SINGLETON");
10134 val ^= DF_1_SINGLETON;
10135 }
10136 if (val & DF_1_STUB)
10137 {
10138 printf (" STUB");
10139 val ^= DF_1_STUB;
10140 }
10141 if (val & DF_1_PIE)
10142 {
10143 printf (" PIE");
10144 val ^= DF_1_PIE;
10145 }
10146 if (val & DF_1_KMOD)
10147 {
10148 printf (" KMOD");
10149 val ^= DF_1_KMOD;
10150 }
10151 if (val & DF_1_WEAKFILTER)
10152 {
10153 printf (" WEAKFILTER");
10154 val ^= DF_1_WEAKFILTER;
10155 }
10156 if (val & DF_1_NOCOMMON)
10157 {
10158 printf (" NOCOMMON");
10159 val ^= DF_1_NOCOMMON;
10160 }
10161 if (val != 0)
10162 printf (" %lx", val);
10163 puts ("");
10164 }
10165 }
10166 break;
10167
10168 case DT_PLTREL:
10169 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10170 if (do_dynamic)
10171 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10172 break;
10173
10174 case DT_NULL :
10175 case DT_NEEDED :
10176 case DT_PLTGOT :
10177 case DT_HASH :
10178 case DT_STRTAB :
10179 case DT_SYMTAB :
10180 case DT_RELA :
10181 case DT_INIT :
10182 case DT_FINI :
10183 case DT_SONAME :
10184 case DT_RPATH :
10185 case DT_SYMBOLIC:
10186 case DT_REL :
10187 case DT_DEBUG :
10188 case DT_TEXTREL :
10189 case DT_JMPREL :
10190 case DT_RUNPATH :
10191 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10192
10193 if (do_dynamic)
10194 {
10195 char * name;
10196
10197 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10198 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10199 else
10200 name = NULL;
10201
10202 if (name)
10203 {
10204 switch (entry->d_tag)
10205 {
10206 case DT_NEEDED:
10207 printf (_("Shared library: [%s]"), name);
10208
10209 if (streq (name, program_interpreter))
10210 printf (_(" program interpreter"));
10211 break;
10212
10213 case DT_SONAME:
10214 printf (_("Library soname: [%s]"), name);
10215 break;
10216
10217 case DT_RPATH:
10218 printf (_("Library rpath: [%s]"), name);
10219 break;
10220
10221 case DT_RUNPATH:
10222 printf (_("Library runpath: [%s]"), name);
10223 break;
10224
10225 default:
10226 print_vma (entry->d_un.d_val, PREFIX_HEX);
10227 break;
10228 }
10229 }
10230 else
10231 print_vma (entry->d_un.d_val, PREFIX_HEX);
10232
10233 putchar ('\n');
10234 }
10235 break;
10236
10237 case DT_PLTRELSZ:
10238 case DT_RELASZ :
10239 case DT_STRSZ :
10240 case DT_RELSZ :
10241 case DT_RELAENT :
10242 case DT_SYMENT :
10243 case DT_RELENT :
10244 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10245 /* Fall through. */
10246 case DT_PLTPADSZ:
10247 case DT_MOVEENT :
10248 case DT_MOVESZ :
10249 case DT_INIT_ARRAYSZ:
10250 case DT_FINI_ARRAYSZ:
10251 case DT_GNU_CONFLICTSZ:
10252 case DT_GNU_LIBLISTSZ:
10253 if (do_dynamic)
10254 {
10255 print_vma (entry->d_un.d_val, UNSIGNED);
10256 printf (_(" (bytes)\n"));
10257 }
10258 break;
10259
10260 case DT_VERDEFNUM:
10261 case DT_VERNEEDNUM:
10262 case DT_RELACOUNT:
10263 case DT_RELCOUNT:
10264 if (do_dynamic)
10265 {
10266 print_vma (entry->d_un.d_val, UNSIGNED);
10267 putchar ('\n');
10268 }
10269 break;
10270
10271 case DT_SYMINSZ:
10272 case DT_SYMINENT:
10273 case DT_SYMINFO:
10274 case DT_USED:
10275 case DT_INIT_ARRAY:
10276 case DT_FINI_ARRAY:
10277 if (do_dynamic)
10278 {
10279 if (entry->d_tag == DT_USED
10280 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10281 {
10282 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10283
10284 if (*name)
10285 {
10286 printf (_("Not needed object: [%s]\n"), name);
10287 break;
10288 }
10289 }
10290
10291 print_vma (entry->d_un.d_val, PREFIX_HEX);
10292 putchar ('\n');
10293 }
10294 break;
10295
10296 case DT_BIND_NOW:
10297 /* The value of this entry is ignored. */
10298 if (do_dynamic)
10299 putchar ('\n');
10300 break;
10301
10302 case DT_GNU_PRELINKED:
10303 if (do_dynamic)
10304 {
10305 struct tm * tmp;
10306 time_t atime = entry->d_un.d_val;
10307
10308 tmp = gmtime (&atime);
10309 /* PR 17533 file: 041-1244816-0.004. */
10310 if (tmp == NULL)
10311 printf (_("<corrupt time val: %lx"),
10312 (unsigned long) atime);
10313 else
10314 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10315 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10316 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10317
10318 }
10319 break;
10320
10321 case DT_GNU_HASH:
10322 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10323 if (do_dynamic)
10324 {
10325 print_vma (entry->d_un.d_val, PREFIX_HEX);
10326 putchar ('\n');
10327 }
10328 break;
10329
10330 default:
10331 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10332 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10333 entry->d_un.d_val;
10334
10335 if (do_dynamic)
10336 {
10337 switch (filedata->file_header.e_machine)
10338 {
10339 case EM_MIPS:
10340 case EM_MIPS_RS3_LE:
10341 dynamic_section_mips_val (entry);
10342 break;
10343 case EM_PARISC:
10344 dynamic_section_parisc_val (entry);
10345 break;
10346 case EM_IA_64:
10347 dynamic_section_ia64_val (entry);
10348 break;
10349 default:
10350 print_vma (entry->d_un.d_val, PREFIX_HEX);
10351 putchar ('\n');
10352 }
10353 }
10354 break;
10355 }
10356 }
10357
10358 return TRUE;
10359}
10360
10361static char *
10362get_ver_flags (unsigned int flags)
10363{
10364 static char buff[128];
10365
10366 buff[0] = 0;
10367
10368 if (flags == 0)
10369 return _("none");
10370
10371 if (flags & VER_FLG_BASE)
10372 strcat (buff, "BASE");
10373
10374 if (flags & VER_FLG_WEAK)
10375 {
10376 if (flags & VER_FLG_BASE)
10377 strcat (buff, " | ");
10378
10379 strcat (buff, "WEAK");
10380 }
10381
10382 if (flags & VER_FLG_INFO)
10383 {
10384 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10385 strcat (buff, " | ");
10386
10387 strcat (buff, "INFO");
10388 }
10389
10390 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10391 {
10392 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10393 strcat (buff, " | ");
10394
10395 strcat (buff, _("<unknown>"));
10396 }
10397
10398 return buff;
10399}
10400
10401/* Display the contents of the version sections. */
10402
10403static bfd_boolean
10404process_version_sections (Filedata * filedata)
10405{
10406 Elf_Internal_Shdr * section;
10407 unsigned i;
10408 bfd_boolean found = FALSE;
10409
10410 if (! do_version)
10411 return TRUE;
10412
10413 for (i = 0, section = filedata->section_headers;
10414 i < filedata->file_header.e_shnum;
10415 i++, section++)
10416 {
10417 switch (section->sh_type)
10418 {
10419 case SHT_GNU_verdef:
10420 {
10421 Elf_External_Verdef * edefs;
10422 unsigned long idx;
10423 unsigned long cnt;
10424 char * endbuf;
10425
10426 found = TRUE;
10427
10428 printf (ngettext ("\nVersion definition section '%s' "
10429 "contains %u entry:\n",
10430 "\nVersion definition section '%s' "
10431 "contains %u entries:\n",
10432 section->sh_info),
10433 printable_section_name (filedata, section),
10434 section->sh_info);
10435
10436 printf (_(" Addr: 0x"));
10437 printf_vma (section->sh_addr);
10438 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10439 (unsigned long) section->sh_offset, section->sh_link,
10440 printable_section_name_from_index (filedata, section->sh_link));
10441
10442 edefs = (Elf_External_Verdef *)
10443 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10444 _("version definition section"));
10445 if (!edefs)
10446 break;
10447 endbuf = (char *) edefs + section->sh_size;
10448
10449 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10450 {
10451 char * vstart;
10452 Elf_External_Verdef * edef;
10453 Elf_Internal_Verdef ent;
10454 Elf_External_Verdaux * eaux;
10455 Elf_Internal_Verdaux aux;
10456 unsigned long isum;
10457 int j;
10458
10459 vstart = ((char *) edefs) + idx;
10460 if (vstart + sizeof (*edef) > endbuf)
10461 break;
10462
10463 edef = (Elf_External_Verdef *) vstart;
10464
10465 ent.vd_version = BYTE_GET (edef->vd_version);
10466 ent.vd_flags = BYTE_GET (edef->vd_flags);
10467 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10468 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10469 ent.vd_hash = BYTE_GET (edef->vd_hash);
10470 ent.vd_aux = BYTE_GET (edef->vd_aux);
10471 ent.vd_next = BYTE_GET (edef->vd_next);
10472
10473 printf (_(" %#06lx: Rev: %d Flags: %s"),
10474 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10475
10476 printf (_(" Index: %d Cnt: %d "),
10477 ent.vd_ndx, ent.vd_cnt);
10478
10479 /* Check for overflow. */
10480 if (ent.vd_aux > (size_t) (endbuf - vstart))
10481 break;
10482
10483 vstart += ent.vd_aux;
10484
10485 if (vstart + sizeof (*eaux) > endbuf)
10486 break;
10487 eaux = (Elf_External_Verdaux *) vstart;
10488
10489 aux.vda_name = BYTE_GET (eaux->vda_name);
10490 aux.vda_next = BYTE_GET (eaux->vda_next);
10491
10492 if (VALID_DYNAMIC_NAME (aux.vda_name))
10493 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10494 else
10495 printf (_("Name index: %ld\n"), aux.vda_name);
10496
10497 isum = idx + ent.vd_aux;
10498
10499 for (j = 1; j < ent.vd_cnt; j++)
10500 {
10501 if (aux.vda_next < sizeof (*eaux)
10502 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10503 {
10504 warn (_("Invalid vda_next field of %lx\n"),
10505 aux.vda_next);
10506 j = ent.vd_cnt;
10507 break;
10508 }
10509 /* Check for overflow. */
10510 if (aux.vda_next > (size_t) (endbuf - vstart))
10511 break;
10512
10513 isum += aux.vda_next;
10514 vstart += aux.vda_next;
10515
10516 if (vstart + sizeof (*eaux) > endbuf)
10517 break;
10518 eaux = (Elf_External_Verdaux *) vstart;
10519
10520 aux.vda_name = BYTE_GET (eaux->vda_name);
10521 aux.vda_next = BYTE_GET (eaux->vda_next);
10522
10523 if (VALID_DYNAMIC_NAME (aux.vda_name))
10524 printf (_(" %#06lx: Parent %d: %s\n"),
10525 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10526 else
10527 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10528 isum, j, aux.vda_name);
10529 }
10530
10531 if (j < ent.vd_cnt)
10532 printf (_(" Version def aux past end of section\n"));
10533
10534 /* PR 17531:
10535 file: id:000001,src:000172+005151,op:splice,rep:2. */
10536 if (ent.vd_next < sizeof (*edef)
10537 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10538 {
10539 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10540 cnt = section->sh_info;
10541 break;
10542 }
10543 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10544 break;
10545
10546 idx += ent.vd_next;
10547 }
10548
10549 if (cnt < section->sh_info)
10550 printf (_(" Version definition past end of section\n"));
10551
10552 free (edefs);
10553 }
10554 break;
10555
10556 case SHT_GNU_verneed:
10557 {
10558 Elf_External_Verneed * eneed;
10559 unsigned long idx;
10560 unsigned long cnt;
10561 char * endbuf;
10562
10563 found = TRUE;
10564
10565 printf (ngettext ("\nVersion needs section '%s' "
10566 "contains %u entry:\n",
10567 "\nVersion needs section '%s' "
10568 "contains %u entries:\n",
10569 section->sh_info),
10570 printable_section_name (filedata, section), section->sh_info);
10571
10572 printf (_(" Addr: 0x"));
10573 printf_vma (section->sh_addr);
10574 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10575 (unsigned long) section->sh_offset, section->sh_link,
10576 printable_section_name_from_index (filedata, section->sh_link));
10577
10578 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10579 section->sh_offset, 1,
10580 section->sh_size,
10581 _("Version Needs section"));
10582 if (!eneed)
10583 break;
10584 endbuf = (char *) eneed + section->sh_size;
10585
10586 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10587 {
10588 Elf_External_Verneed * entry;
10589 Elf_Internal_Verneed ent;
10590 unsigned long isum;
10591 int j;
10592 char * vstart;
10593
10594 vstart = ((char *) eneed) + idx;
10595 if (vstart + sizeof (*entry) > endbuf)
10596 break;
10597
10598 entry = (Elf_External_Verneed *) vstart;
10599
10600 ent.vn_version = BYTE_GET (entry->vn_version);
10601 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10602 ent.vn_file = BYTE_GET (entry->vn_file);
10603 ent.vn_aux = BYTE_GET (entry->vn_aux);
10604 ent.vn_next = BYTE_GET (entry->vn_next);
10605
10606 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10607
10608 if (VALID_DYNAMIC_NAME (ent.vn_file))
10609 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10610 else
10611 printf (_(" File: %lx"), ent.vn_file);
10612
10613 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10614
10615 /* Check for overflow. */
10616 if (ent.vn_aux > (size_t) (endbuf - vstart))
10617 break;
10618 vstart += ent.vn_aux;
10619
10620 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10621 {
10622 Elf_External_Vernaux * eaux;
10623 Elf_Internal_Vernaux aux;
10624
10625 if (vstart + sizeof (*eaux) > endbuf)
10626 break;
10627 eaux = (Elf_External_Vernaux *) vstart;
10628
10629 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10630 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10631 aux.vna_other = BYTE_GET (eaux->vna_other);
10632 aux.vna_name = BYTE_GET (eaux->vna_name);
10633 aux.vna_next = BYTE_GET (eaux->vna_next);
10634
10635 if (VALID_DYNAMIC_NAME (aux.vna_name))
10636 printf (_(" %#06lx: Name: %s"),
10637 isum, GET_DYNAMIC_NAME (aux.vna_name));
10638 else
10639 printf (_(" %#06lx: Name index: %lx"),
10640 isum, aux.vna_name);
10641
10642 printf (_(" Flags: %s Version: %d\n"),
10643 get_ver_flags (aux.vna_flags), aux.vna_other);
10644
10645 if (aux.vna_next < sizeof (*eaux)
10646 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10647 {
10648 warn (_("Invalid vna_next field of %lx\n"),
10649 aux.vna_next);
10650 j = ent.vn_cnt;
10651 break;
10652 }
10653 /* Check for overflow. */
10654 if (aux.vna_next > (size_t) (endbuf - vstart))
10655 break;
10656 isum += aux.vna_next;
10657 vstart += aux.vna_next;
10658 }
10659
10660 if (j < ent.vn_cnt)
10661 warn (_("Missing Version Needs auxillary information\n"));
10662
10663 if (ent.vn_next < sizeof (*entry)
10664 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10665 {
10666 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10667 cnt = section->sh_info;
10668 break;
10669 }
10670 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10671 break;
10672 idx += ent.vn_next;
10673 }
10674
10675 if (cnt < section->sh_info)
10676 warn (_("Missing Version Needs information\n"));
10677
10678 free (eneed);
10679 }
10680 break;
10681
10682 case SHT_GNU_versym:
10683 {
10684 Elf_Internal_Shdr * link_section;
10685 size_t total;
10686 unsigned int cnt;
10687 unsigned char * edata;
10688 unsigned short * data;
10689 char * strtab;
10690 Elf_Internal_Sym * symbols;
10691 Elf_Internal_Shdr * string_sec;
10692 unsigned long num_syms;
10693 long off;
10694
10695 if (section->sh_link >= filedata->file_header.e_shnum)
10696 break;
10697
10698 link_section = filedata->section_headers + section->sh_link;
10699 total = section->sh_size / sizeof (Elf_External_Versym);
10700
10701 if (link_section->sh_link >= filedata->file_header.e_shnum)
10702 break;
10703
10704 found = TRUE;
10705
10706 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10707 if (symbols == NULL)
10708 break;
10709
10710 string_sec = filedata->section_headers + link_section->sh_link;
10711
10712 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10713 string_sec->sh_size,
10714 _("version string table"));
10715 if (!strtab)
10716 {
10717 free (symbols);
10718 break;
10719 }
10720
10721 printf (ngettext ("\nVersion symbols section '%s' "
10722 "contains %lu entry:\n",
10723 "\nVersion symbols section '%s' "
10724 "contains %lu entries:\n",
10725 total),
10726 printable_section_name (filedata, section), (unsigned long) total);
10727
10728 printf (_(" Addr: "));
10729 printf_vma (section->sh_addr);
10730 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10731 (unsigned long) section->sh_offset, section->sh_link,
10732 printable_section_name (filedata, link_section));
10733
10734 off = offset_from_vma (filedata,
10735 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10736 total * sizeof (short));
10737 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10738 sizeof (short),
10739 _("version symbol data"));
10740 if (!edata)
10741 {
10742 free (strtab);
10743 free (symbols);
10744 break;
10745 }
10746
10747 data = (short unsigned int *) cmalloc (total, sizeof (short));
10748
10749 for (cnt = total; cnt --;)
10750 data[cnt] = byte_get (edata + cnt * sizeof (short),
10751 sizeof (short));
10752
10753 free (edata);
10754
10755 for (cnt = 0; cnt < total; cnt += 4)
10756 {
10757 int j, nn;
10758 char *name;
10759 char *invalid = _("*invalid*");
10760
10761 printf (" %03x:", cnt);
10762
10763 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10764 switch (data[cnt + j])
10765 {
10766 case 0:
10767 fputs (_(" 0 (*local*) "), stdout);
10768 break;
10769
10770 case 1:
10771 fputs (_(" 1 (*global*) "), stdout);
10772 break;
10773
10774 default:
10775 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10776 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10777
10778 /* If this index value is greater than the size of the symbols
10779 array, break to avoid an out-of-bounds read. */
10780 if ((unsigned long)(cnt + j) >= num_syms)
10781 {
10782 warn (_("invalid index into symbol array\n"));
10783 break;
10784 }
10785
10786 name = NULL;
10787 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10788 {
10789 Elf_Internal_Verneed ivn;
10790 unsigned long offset;
10791
10792 offset = offset_from_vma
10793 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10794 sizeof (Elf_External_Verneed));
10795
10796 do
10797 {
10798 Elf_Internal_Vernaux ivna;
10799 Elf_External_Verneed evn;
10800 Elf_External_Vernaux evna;
10801 unsigned long a_off;
10802
10803 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10804 _("version need")) == NULL)
10805 break;
10806
10807 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10808 ivn.vn_next = BYTE_GET (evn.vn_next);
10809
10810 a_off = offset + ivn.vn_aux;
10811
10812 do
10813 {
10814 if (get_data (&evna, filedata, a_off, sizeof (evna),
10815 1, _("version need aux (2)")) == NULL)
10816 {
10817 ivna.vna_next = 0;
10818 ivna.vna_other = 0;
10819 }
10820 else
10821 {
10822 ivna.vna_next = BYTE_GET (evna.vna_next);
10823 ivna.vna_other = BYTE_GET (evna.vna_other);
10824 }
10825
10826 a_off += ivna.vna_next;
10827 }
10828 while (ivna.vna_other != data[cnt + j]
10829 && ivna.vna_next != 0);
10830
10831 if (ivna.vna_other == data[cnt + j])
10832 {
10833 ivna.vna_name = BYTE_GET (evna.vna_name);
10834
10835 if (ivna.vna_name >= string_sec->sh_size)
10836 name = invalid;
10837 else
10838 name = strtab + ivna.vna_name;
10839 break;
10840 }
10841
10842 offset += ivn.vn_next;
10843 }
10844 while (ivn.vn_next);
10845 }
10846
10847 if (data[cnt + j] != 0x8001
10848 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10849 {
10850 Elf_Internal_Verdef ivd;
10851 Elf_External_Verdef evd;
10852 unsigned long offset;
10853
10854 offset = offset_from_vma
10855 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10856 sizeof evd);
10857
10858 do
10859 {
10860 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10861 _("version def")) == NULL)
10862 {
10863 ivd.vd_next = 0;
10864 /* PR 17531: file: 046-1082287-0.004. */
10865 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10866 break;
10867 }
10868 else
10869 {
10870 ivd.vd_next = BYTE_GET (evd.vd_next);
10871 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10872 }
10873
10874 offset += ivd.vd_next;
10875 }
10876 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10877 && ivd.vd_next != 0);
10878
10879 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10880 {
10881 Elf_External_Verdaux evda;
10882 Elf_Internal_Verdaux ivda;
10883
10884 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10885
10886 if (get_data (&evda, filedata,
10887 offset - ivd.vd_next + ivd.vd_aux,
10888 sizeof (evda), 1,
10889 _("version def aux")) == NULL)
10890 break;
10891
10892 ivda.vda_name = BYTE_GET (evda.vda_name);
10893
10894 if (ivda.vda_name >= string_sec->sh_size)
10895 name = invalid;
10896 else if (name != NULL && name != invalid)
10897 name = _("*both*");
10898 else
10899 name = strtab + ivda.vda_name;
10900 }
10901 }
10902 if (name != NULL)
10903 nn += printf ("(%s%-*s",
10904 name,
10905 12 - (int) strlen (name),
10906 ")");
10907
10908 if (nn < 18)
10909 printf ("%*c", 18 - nn, ' ');
10910 }
10911
10912 putchar ('\n');
10913 }
10914
10915 free (data);
10916 free (strtab);
10917 free (symbols);
10918 }
10919 break;
10920
10921 default:
10922 break;
10923 }
10924 }
10925
10926 if (! found)
10927 printf (_("\nNo version information found in this file.\n"));
10928
10929 return TRUE;
10930}
10931
10932static const char *
10933get_symbol_binding (Filedata * filedata, unsigned int binding)
10934{
10935 static char buff[32];
10936
10937 switch (binding)
10938 {
10939 case STB_LOCAL: return "LOCAL";
10940 case STB_GLOBAL: return "GLOBAL";
10941 case STB_WEAK: return "WEAK";
10942 default:
10943 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10944 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10945 binding);
10946 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10947 {
10948 if (binding == STB_GNU_UNIQUE
10949 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10950 /* GNU is still using the default value 0. */
10951 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10952 return "UNIQUE";
10953 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10954 }
10955 else
10956 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10957 return buff;
10958 }
10959}
10960
10961static const char *
10962get_symbol_type (Filedata * filedata, unsigned int type)
10963{
10964 static char buff[32];
10965
10966 switch (type)
10967 {
10968 case STT_NOTYPE: return "NOTYPE";
10969 case STT_OBJECT: return "OBJECT";
10970 case STT_FUNC: return "FUNC";
10971 case STT_SECTION: return "SECTION";
10972 case STT_FILE: return "FILE";
10973 case STT_COMMON: return "COMMON";
10974 case STT_TLS: return "TLS";
10975 case STT_RELC: return "RELC";
10976 case STT_SRELC: return "SRELC";
10977 default:
10978 if (type >= STT_LOPROC && type <= STT_HIPROC)
10979 {
10980 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10981 return "THUMB_FUNC";
10982
10983 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10984 return "REGISTER";
10985
10986 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10987 return "PARISC_MILLI";
10988
10989 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10990 }
10991 else if (type >= STT_LOOS && type <= STT_HIOS)
10992 {
10993 if (filedata->file_header.e_machine == EM_PARISC)
10994 {
10995 if (type == STT_HP_OPAQUE)
10996 return "HP_OPAQUE";
10997 if (type == STT_HP_STUB)
10998 return "HP_STUB";
10999 }
11000
11001 if (type == STT_GNU_IFUNC
11002 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11003 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11004 /* GNU is still using the default value 0. */
11005 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11006 return "IFUNC";
11007
11008 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11009 }
11010 else
11011 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11012 return buff;
11013 }
11014}
11015
11016static const char *
11017get_symbol_visibility (unsigned int visibility)
11018{
11019 switch (visibility)
11020 {
11021 case STV_DEFAULT: return "DEFAULT";
11022 case STV_INTERNAL: return "INTERNAL";
11023 case STV_HIDDEN: return "HIDDEN";
11024 case STV_PROTECTED: return "PROTECTED";
11025 default:
11026 error (_("Unrecognized visibility value: %u"), visibility);
11027 return _("<unknown>");
11028 }
11029}
11030
11031static const char *
11032get_solaris_symbol_visibility (unsigned int visibility)
11033{
11034 switch (visibility)
11035 {
11036 case 4: return "EXPORTED";
11037 case 5: return "SINGLETON";
11038 case 6: return "ELIMINATE";
11039 default: return get_symbol_visibility (visibility);
11040 }
11041}
11042
11043static const char *
11044get_mips_symbol_other (unsigned int other)
11045{
11046 switch (other)
11047 {
11048 case STO_OPTIONAL: return "OPTIONAL";
11049 case STO_MIPS_PLT: return "MIPS PLT";
11050 case STO_MIPS_PIC: return "MIPS PIC";
11051 case STO_MICROMIPS: return "MICROMIPS";
11052 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11053 case STO_MIPS16: return "MIPS16";
11054 default: return NULL;
11055 }
11056}
11057
11058static const char *
11059get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11060{
11061 if (is_ia64_vms (filedata))
11062 {
11063 static char res[32];
11064
11065 res[0] = 0;
11066
11067 /* Function types is for images and .STB files only. */
11068 switch (filedata->file_header.e_type)
11069 {
11070 case ET_DYN:
11071 case ET_EXEC:
11072 switch (VMS_ST_FUNC_TYPE (other))
11073 {
11074 case VMS_SFT_CODE_ADDR:
11075 strcat (res, " CA");
11076 break;
11077 case VMS_SFT_SYMV_IDX:
11078 strcat (res, " VEC");
11079 break;
11080 case VMS_SFT_FD:
11081 strcat (res, " FD");
11082 break;
11083 case VMS_SFT_RESERVE:
11084 strcat (res, " RSV");
11085 break;
11086 default:
11087 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11088 VMS_ST_FUNC_TYPE (other));
11089 strcat (res, " <unknown>");
11090 break;
11091 }
11092 break;
11093 default:
11094 break;
11095 }
11096 switch (VMS_ST_LINKAGE (other))
11097 {
11098 case VMS_STL_IGNORE:
11099 strcat (res, " IGN");
11100 break;
11101 case VMS_STL_RESERVE:
11102 strcat (res, " RSV");
11103 break;
11104 case VMS_STL_STD:
11105 strcat (res, " STD");
11106 break;
11107 case VMS_STL_LNK:
11108 strcat (res, " LNK");
11109 break;
11110 default:
11111 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11112 VMS_ST_LINKAGE (other));
11113 strcat (res, " <unknown>");
11114 break;
11115 }
11116
11117 if (res[0] != 0)
11118 return res + 1;
11119 else
11120 return res;
11121 }
11122 return NULL;
11123}
11124
11125static const char *
11126get_ppc64_symbol_other (unsigned int other)
11127{
11128 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11129 return NULL;
11130
11131 other >>= STO_PPC64_LOCAL_BIT;
11132 if (other <= 6)
11133 {
11134 static char buf[32];
11135 if (other >= 2)
11136 other = ppc64_decode_local_entry (other);
11137 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11138 return buf;
11139 }
11140 return NULL;
11141}
11142
11143static const char *
11144get_symbol_other (Filedata * filedata, unsigned int other)
11145{
11146 const char * result = NULL;
11147 static char buff [32];
11148
11149 if (other == 0)
11150 return "";
11151
11152 switch (filedata->file_header.e_machine)
11153 {
11154 case EM_MIPS:
11155 result = get_mips_symbol_other (other);
11156 break;
11157 case EM_IA_64:
11158 result = get_ia64_symbol_other (filedata, other);
11159 break;
11160 case EM_PPC64:
11161 result = get_ppc64_symbol_other (other);
11162 break;
11163 default:
11164 result = NULL;
11165 break;
11166 }
11167
11168 if (result)
11169 return result;
11170
11171 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11172 return buff;
11173}
11174
11175static const char *
11176get_symbol_index_type (Filedata * filedata, unsigned int type)
11177{
11178 static char buff[32];
11179
11180 switch (type)
11181 {
11182 case SHN_UNDEF: return "UND";
11183 case SHN_ABS: return "ABS";
11184 case SHN_COMMON: return "COM";
11185 default:
11186 if (type == SHN_IA_64_ANSI_COMMON
11187 && filedata->file_header.e_machine == EM_IA_64
11188 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11189 return "ANSI_COM";
11190 else if ((filedata->file_header.e_machine == EM_X86_64
11191 || filedata->file_header.e_machine == EM_L1OM
11192 || filedata->file_header.e_machine == EM_K1OM)
11193 && type == SHN_X86_64_LCOMMON)
11194 return "LARGE_COM";
11195 else if ((type == SHN_MIPS_SCOMMON
11196 && filedata->file_header.e_machine == EM_MIPS)
11197 || (type == SHN_TIC6X_SCOMMON
11198 && filedata->file_header.e_machine == EM_TI_C6000))
11199 return "SCOM";
11200 else if (type == SHN_MIPS_SUNDEFINED
11201 && filedata->file_header.e_machine == EM_MIPS)
11202 return "SUND";
11203 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11204 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11205 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11206 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11207 else if (type >= SHN_LORESERVE)
11208 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11209 else if (type >= filedata->file_header.e_shnum)
11210 sprintf (buff, _("bad section index[%3d]"), type);
11211 else
11212 sprintf (buff, "%3d", type);
11213 break;
11214 }
11215
11216 return buff;
11217}
11218
11219static bfd_vma *
11220get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11221{
11222 unsigned char * e_data;
11223 bfd_vma * i_data;
11224
11225 /* If the size_t type is smaller than the bfd_size_type, eg because
11226 you are building a 32-bit tool on a 64-bit host, then make sure
11227 that when (number) is cast to (size_t) no information is lost. */
11228 if (sizeof (size_t) < sizeof (bfd_size_type)
11229 && (bfd_size_type) ((size_t) number) != number)
11230 {
11231 error (_("Size truncation prevents reading %s elements of size %u\n"),
11232 bfd_vmatoa ("u", number), ent_size);
11233 return NULL;
11234 }
11235
11236 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11237 attempting to allocate memory when the read is bound to fail. */
11238 if (ent_size * number > filedata->file_size)
11239 {
11240 error (_("Invalid number of dynamic entries: %s\n"),
11241 bfd_vmatoa ("u", number));
11242 return NULL;
11243 }
11244
11245 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11246 if (e_data == NULL)
11247 {
11248 error (_("Out of memory reading %s dynamic entries\n"),
11249 bfd_vmatoa ("u", number));
11250 return NULL;
11251 }
11252
11253 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11254 {
11255 error (_("Unable to read in %s bytes of dynamic data\n"),
11256 bfd_vmatoa ("u", number * ent_size));
11257 free (e_data);
11258 return NULL;
11259 }
11260
11261 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11262 if (i_data == NULL)
11263 {
11264 error (_("Out of memory allocating space for %s dynamic entries\n"),
11265 bfd_vmatoa ("u", number));
11266 free (e_data);
11267 return NULL;
11268 }
11269
11270 while (number--)
11271 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11272
11273 free (e_data);
11274
11275 return i_data;
11276}
11277
11278static void
11279print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11280{
11281 Elf_Internal_Sym * psym;
11282 int n;
11283
11284 n = print_vma (si, DEC_5);
11285 if (n < 5)
11286 fputs (&" "[n], stdout);
11287 printf (" %3lu: ", hn);
11288
11289 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11290 {
11291 printf (_("<No info available for dynamic symbol number %lu>\n"),
11292 (unsigned long) si);
11293 return;
11294 }
11295
11296 psym = dynamic_symbols + si;
11297 print_vma (psym->st_value, LONG_HEX);
11298 putchar (' ');
11299 print_vma (psym->st_size, DEC_5);
11300
11301 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11302 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11303
11304 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11305 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11306 else
11307 {
11308 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11309
11310 printf (" %-7s", get_symbol_visibility (vis));
11311 /* Check to see if any other bits in the st_other field are set.
11312 Note - displaying this information disrupts the layout of the
11313 table being generated, but for the moment this case is very
11314 rare. */
11315 if (psym->st_other ^ vis)
11316 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11317 }
11318
11319 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11320 if (VALID_DYNAMIC_NAME (psym->st_name))
11321 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11322 else
11323 printf (_(" <corrupt: %14ld>"), psym->st_name);
11324 putchar ('\n');
11325}
11326
11327static const char *
11328get_symbol_version_string (Filedata * filedata,
11329 bfd_boolean is_dynsym,
11330 const char * strtab,
11331 unsigned long int strtab_size,
11332 unsigned int si,
11333 Elf_Internal_Sym * psym,
11334 enum versioned_symbol_info * sym_info,
11335 unsigned short * vna_other)
11336{
11337 unsigned char data[2];
11338 unsigned short vers_data;
11339 unsigned long offset;
11340 unsigned short max_vd_ndx;
11341
11342 if (!is_dynsym
11343 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11344 return NULL;
11345
11346 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11347 sizeof data + si * sizeof (vers_data));
11348
11349 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11350 sizeof (data), 1, _("version data")) == NULL)
11351 return NULL;
11352
11353 vers_data = byte_get (data, 2);
11354
11355 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11356 return NULL;
11357
11358 max_vd_ndx = 0;
11359
11360 /* Usually we'd only see verdef for defined symbols, and verneed for
11361 undefined symbols. However, symbols defined by the linker in
11362 .dynbss for variables copied from a shared library in order to
11363 avoid text relocations are defined yet have verneed. We could
11364 use a heuristic to detect the special case, for example, check
11365 for verneed first on symbols defined in SHT_NOBITS sections, but
11366 it is simpler and more reliable to just look for both verdef and
11367 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11368
11369 if (psym->st_shndx != SHN_UNDEF
11370 && vers_data != 0x8001
11371 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11372 {
11373 Elf_Internal_Verdef ivd;
11374 Elf_Internal_Verdaux ivda;
11375 Elf_External_Verdaux evda;
11376 unsigned long off;
11377
11378 off = offset_from_vma (filedata,
11379 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11380 sizeof (Elf_External_Verdef));
11381
11382 do
11383 {
11384 Elf_External_Verdef evd;
11385
11386 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11387 _("version def")) == NULL)
11388 {
11389 ivd.vd_ndx = 0;
11390 ivd.vd_aux = 0;
11391 ivd.vd_next = 0;
11392 ivd.vd_flags = 0;
11393 }
11394 else
11395 {
11396 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11397 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11398 ivd.vd_next = BYTE_GET (evd.vd_next);
11399 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11400 }
11401
11402 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11403 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11404
11405 off += ivd.vd_next;
11406 }
11407 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11408
11409 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11410 {
11411 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11412 return NULL;
11413
11414 off -= ivd.vd_next;
11415 off += ivd.vd_aux;
11416
11417 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11418 _("version def aux")) != NULL)
11419 {
11420 ivda.vda_name = BYTE_GET (evda.vda_name);
11421
11422 if (psym->st_name != ivda.vda_name)
11423 {
11424 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11425 ? symbol_hidden : symbol_public);
11426 return (ivda.vda_name < strtab_size
11427 ? strtab + ivda.vda_name : _("<corrupt>"));
11428 }
11429 }
11430 }
11431 }
11432
11433 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11434 {
11435 Elf_External_Verneed evn;
11436 Elf_Internal_Verneed ivn;
11437 Elf_Internal_Vernaux ivna;
11438
11439 offset = offset_from_vma (filedata,
11440 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11441 sizeof evn);
11442 do
11443 {
11444 unsigned long vna_off;
11445
11446 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11447 _("version need")) == NULL)
11448 {
11449 ivna.vna_next = 0;
11450 ivna.vna_other = 0;
11451 ivna.vna_name = 0;
11452 break;
11453 }
11454
11455 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11456 ivn.vn_next = BYTE_GET (evn.vn_next);
11457
11458 vna_off = offset + ivn.vn_aux;
11459
11460 do
11461 {
11462 Elf_External_Vernaux evna;
11463
11464 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11465 _("version need aux (3)")) == NULL)
11466 {
11467 ivna.vna_next = 0;
11468 ivna.vna_other = 0;
11469 ivna.vna_name = 0;
11470 }
11471 else
11472 {
11473 ivna.vna_other = BYTE_GET (evna.vna_other);
11474 ivna.vna_next = BYTE_GET (evna.vna_next);
11475 ivna.vna_name = BYTE_GET (evna.vna_name);
11476 }
11477
11478 vna_off += ivna.vna_next;
11479 }
11480 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11481
11482 if (ivna.vna_other == vers_data)
11483 break;
11484
11485 offset += ivn.vn_next;
11486 }
11487 while (ivn.vn_next != 0);
11488
11489 if (ivna.vna_other == vers_data)
11490 {
11491 *sym_info = symbol_undefined;
11492 *vna_other = ivna.vna_other;
11493 return (ivna.vna_name < strtab_size
11494 ? strtab + ivna.vna_name : _("<corrupt>"));
11495 }
11496 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11497 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11498 return _("<corrupt>");
11499 }
11500 return NULL;
11501}
11502
11503/* Dump the symbol table. */
11504static bfd_boolean
11505process_symbol_table (Filedata * filedata)
11506{
11507 Elf_Internal_Shdr * section;
11508 bfd_size_type nbuckets = 0;
11509 bfd_size_type nchains = 0;
11510 bfd_vma * buckets = NULL;
11511 bfd_vma * chains = NULL;
11512 bfd_vma ngnubuckets = 0;
11513 bfd_vma * gnubuckets = NULL;
11514 bfd_vma * gnuchains = NULL;
11515 bfd_vma gnusymidx = 0;
11516 bfd_size_type ngnuchains = 0;
11517
11518 if (!do_syms && !do_dyn_syms && !do_histogram)
11519 return TRUE;
11520
11521 if (dynamic_info[DT_HASH]
11522 && (do_histogram
11523 || (do_using_dynamic
11524 && !do_dyn_syms
11525 && dynamic_strings != NULL)))
11526 {
11527 unsigned char nb[8];
11528 unsigned char nc[8];
11529 unsigned int hash_ent_size = 4;
11530
11531 if ((filedata->file_header.e_machine == EM_ALPHA
11532 || filedata->file_header.e_machine == EM_S390
11533 || filedata->file_header.e_machine == EM_S390_OLD)
11534 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11535 hash_ent_size = 8;
11536
11537 if (fseek (filedata->handle,
11538 (archive_file_offset
11539 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11540 sizeof nb + sizeof nc)),
11541 SEEK_SET))
11542 {
11543 error (_("Unable to seek to start of dynamic information\n"));
11544 goto no_hash;
11545 }
11546
11547 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11548 {
11549 error (_("Failed to read in number of buckets\n"));
11550 goto no_hash;
11551 }
11552
11553 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11554 {
11555 error (_("Failed to read in number of chains\n"));
11556 goto no_hash;
11557 }
11558
11559 nbuckets = byte_get (nb, hash_ent_size);
11560 nchains = byte_get (nc, hash_ent_size);
11561
11562 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11563 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11564
11565 no_hash:
11566 if (buckets == NULL || chains == NULL)
11567 {
11568 if (do_using_dynamic)
11569 return FALSE;
11570 free (buckets);
11571 free (chains);
11572 buckets = NULL;
11573 chains = NULL;
11574 nbuckets = 0;
11575 nchains = 0;
11576 }
11577 }
11578
11579 if (dynamic_info_DT_GNU_HASH
11580 && (do_histogram
11581 || (do_using_dynamic
11582 && !do_dyn_syms
11583 && dynamic_strings != NULL)))
11584 {
11585 unsigned char nb[16];
11586 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11587 bfd_vma buckets_vma;
11588
11589 if (fseek (filedata->handle,
11590 (archive_file_offset
11591 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11592 sizeof nb)),
11593 SEEK_SET))
11594 {
11595 error (_("Unable to seek to start of dynamic information\n"));
11596 goto no_gnu_hash;
11597 }
11598
11599 if (fread (nb, 16, 1, filedata->handle) != 1)
11600 {
11601 error (_("Failed to read in number of buckets\n"));
11602 goto no_gnu_hash;
11603 }
11604
11605 ngnubuckets = byte_get (nb, 4);
11606 gnusymidx = byte_get (nb + 4, 4);
11607 bitmaskwords = byte_get (nb + 8, 4);
11608 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11609 if (is_32bit_elf)
11610 buckets_vma += bitmaskwords * 4;
11611 else
11612 buckets_vma += bitmaskwords * 8;
11613
11614 if (fseek (filedata->handle,
11615 (archive_file_offset
11616 + offset_from_vma (filedata, buckets_vma, 4)),
11617 SEEK_SET))
11618 {
11619 error (_("Unable to seek to start of dynamic information\n"));
11620 goto no_gnu_hash;
11621 }
11622
11623 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11624
11625 if (gnubuckets == NULL)
11626 goto no_gnu_hash;
11627
11628 for (i = 0; i < ngnubuckets; i++)
11629 if (gnubuckets[i] != 0)
11630 {
11631 if (gnubuckets[i] < gnusymidx)
11632 return FALSE;
11633
11634 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11635 maxchain = gnubuckets[i];
11636 }
11637
11638 if (maxchain == 0xffffffff)
11639 goto no_gnu_hash;
11640
11641 maxchain -= gnusymidx;
11642
11643 if (fseek (filedata->handle,
11644 (archive_file_offset
11645 + offset_from_vma (filedata, buckets_vma
11646 + 4 * (ngnubuckets + maxchain), 4)),
11647 SEEK_SET))
11648 {
11649 error (_("Unable to seek to start of dynamic information\n"));
11650 goto no_gnu_hash;
11651 }
11652
11653 do
11654 {
11655 if (fread (nb, 4, 1, filedata->handle) != 1)
11656 {
11657 error (_("Failed to determine last chain length\n"));
11658 goto no_gnu_hash;
11659 }
11660
11661 if (maxchain + 1 == 0)
11662 goto no_gnu_hash;
11663
11664 ++maxchain;
11665 }
11666 while ((byte_get (nb, 4) & 1) == 0);
11667
11668 if (fseek (filedata->handle,
11669 (archive_file_offset
11670 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11671 SEEK_SET))
11672 {
11673 error (_("Unable to seek to start of dynamic information\n"));
11674 goto no_gnu_hash;
11675 }
11676
11677 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11678 ngnuchains = maxchain;
11679
11680 no_gnu_hash:
11681 if (gnuchains == NULL)
11682 {
11683 free (gnubuckets);
11684 gnubuckets = NULL;
11685 ngnubuckets = 0;
11686 if (do_using_dynamic)
11687 return FALSE;
11688 }
11689 }
11690
11691 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11692 && do_syms
11693 && do_using_dynamic
11694 && dynamic_strings != NULL
11695 && dynamic_symbols != NULL)
11696 {
11697 unsigned long hn;
11698
11699 if (dynamic_info[DT_HASH])
11700 {
11701 bfd_vma si;
11702 char *visited;
11703
11704 printf (_("\nSymbol table for image:\n"));
11705 if (is_32bit_elf)
11706 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11707 else
11708 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11709
11710 visited = xcmalloc (nchains, 1);
11711 memset (visited, 0, nchains);
11712 for (hn = 0; hn < nbuckets; hn++)
11713 {
11714 for (si = buckets[hn]; si > 0; si = chains[si])
11715 {
11716 print_dynamic_symbol (filedata, si, hn);
11717 if (si >= nchains || visited[si])
11718 {
11719 error (_("histogram chain is corrupt\n"));
11720 break;
11721 }
11722 visited[si] = 1;
11723 }
11724 }
11725 free (visited);
11726 }
11727
11728 if (dynamic_info_DT_GNU_HASH)
11729 {
11730 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11731 if (is_32bit_elf)
11732 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11733 else
11734 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11735
11736 for (hn = 0; hn < ngnubuckets; ++hn)
11737 if (gnubuckets[hn] != 0)
11738 {
11739 bfd_vma si = gnubuckets[hn];
11740 bfd_vma off = si - gnusymidx;
11741
11742 do
11743 {
11744 print_dynamic_symbol (filedata, si, hn);
11745 si++;
11746 }
11747 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11748 }
11749 }
11750 }
11751 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11752 && filedata->section_headers != NULL)
11753 {
11754 unsigned int i;
11755
11756 for (i = 0, section = filedata->section_headers;
11757 i < filedata->file_header.e_shnum;
11758 i++, section++)
11759 {
11760 unsigned int si;
11761 char * strtab = NULL;
11762 unsigned long int strtab_size = 0;
11763 Elf_Internal_Sym * symtab;
11764 Elf_Internal_Sym * psym;
11765 unsigned long num_syms;
11766
11767 if ((section->sh_type != SHT_SYMTAB
11768 && section->sh_type != SHT_DYNSYM)
11769 || (!do_syms
11770 && section->sh_type == SHT_SYMTAB))
11771 continue;
11772
11773 if (section->sh_entsize == 0)
11774 {
11775 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11776 printable_section_name (filedata, section));
11777 continue;
11778 }
11779
11780 num_syms = section->sh_size / section->sh_entsize;
11781 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11782 "\nSymbol table '%s' contains %lu entries:\n",
11783 num_syms),
11784 printable_section_name (filedata, section),
11785 num_syms);
11786
11787 if (is_32bit_elf)
11788 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11789 else
11790 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11791
11792 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11793 if (symtab == NULL)
11794 continue;
11795
11796 if (section->sh_link == filedata->file_header.e_shstrndx)
11797 {
11798 strtab = filedata->string_table;
11799 strtab_size = filedata->string_table_length;
11800 }
11801 else if (section->sh_link < filedata->file_header.e_shnum)
11802 {
11803 Elf_Internal_Shdr * string_sec;
11804
11805 string_sec = filedata->section_headers + section->sh_link;
11806
11807 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11808 1, string_sec->sh_size,
11809 _("string table"));
11810 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11811 }
11812
11813 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11814 {
11815 const char *version_string;
11816 enum versioned_symbol_info sym_info;
11817 unsigned short vna_other;
11818
11819 printf ("%6d: ", si);
11820 print_vma (psym->st_value, LONG_HEX);
11821 putchar (' ');
11822 print_vma (psym->st_size, DEC_5);
11823 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11824 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11825 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11826 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11827 else
11828 {
11829 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11830
11831 printf (" %-7s", get_symbol_visibility (vis));
11832 /* Check to see if any other bits in the st_other field are set.
11833 Note - displaying this information disrupts the layout of the
11834 table being generated, but for the moment this case is very rare. */
11835 if (psym->st_other ^ vis)
11836 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11837 }
11838 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11839 print_symbol (25, psym->st_name < strtab_size
11840 ? strtab + psym->st_name : _("<corrupt>"));
11841
11842 version_string
11843 = get_symbol_version_string (filedata,
11844 section->sh_type == SHT_DYNSYM,
11845 strtab, strtab_size, si,
11846 psym, &sym_info, &vna_other);
11847 if (version_string)
11848 {
11849 if (sym_info == symbol_undefined)
11850 printf ("@%s (%d)", version_string, vna_other);
11851 else
11852 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11853 version_string);
11854 }
11855
11856 putchar ('\n');
11857
11858 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11859 && si >= section->sh_info
11860 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11861 && filedata->file_header.e_machine != EM_MIPS
11862 /* Solaris binaries have been found to violate this requirement as
11863 well. Not sure if this is a bug or an ABI requirement. */
11864 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11865 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11866 si, printable_section_name (filedata, section), section->sh_info);
11867 }
11868
11869 free (symtab);
11870 if (strtab != filedata->string_table)
11871 free (strtab);
11872 }
11873 }
11874 else if (do_syms)
11875 printf
11876 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11877
11878 if (do_histogram && buckets != NULL)
11879 {
11880 unsigned long * lengths;
11881 unsigned long * counts;
11882 unsigned long hn;
11883 bfd_vma si;
11884 unsigned long maxlength = 0;
11885 unsigned long nzero_counts = 0;
11886 unsigned long nsyms = 0;
11887 char *visited;
11888
11889 printf (ngettext ("\nHistogram for bucket list length "
11890 "(total of %lu bucket):\n",
11891 "\nHistogram for bucket list length "
11892 "(total of %lu buckets):\n",
11893 (unsigned long) nbuckets),
11894 (unsigned long) nbuckets);
11895
11896 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11897 if (lengths == NULL)
11898 {
11899 error (_("Out of memory allocating space for histogram buckets\n"));
11900 return FALSE;
11901 }
11902 visited = xcmalloc (nchains, 1);
11903 memset (visited, 0, nchains);
11904
11905 printf (_(" Length Number %% of total Coverage\n"));
11906 for (hn = 0; hn < nbuckets; ++hn)
11907 {
11908 for (si = buckets[hn]; si > 0; si = chains[si])
11909 {
11910 ++nsyms;
11911 if (maxlength < ++lengths[hn])
11912 ++maxlength;
11913 if (si >= nchains || visited[si])
11914 {
11915 error (_("histogram chain is corrupt\n"));
11916 break;
11917 }
11918 visited[si] = 1;
11919 }
11920 }
11921 free (visited);
11922
11923 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11924 if (counts == NULL)
11925 {
11926 free (lengths);
11927 error (_("Out of memory allocating space for histogram counts\n"));
11928 return FALSE;
11929 }
11930
11931 for (hn = 0; hn < nbuckets; ++hn)
11932 ++counts[lengths[hn]];
11933
11934 if (nbuckets > 0)
11935 {
11936 unsigned long i;
11937 printf (" 0 %-10lu (%5.1f%%)\n",
11938 counts[0], (counts[0] * 100.0) / nbuckets);
11939 for (i = 1; i <= maxlength; ++i)
11940 {
11941 nzero_counts += counts[i] * i;
11942 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11943 i, counts[i], (counts[i] * 100.0) / nbuckets,
11944 (nzero_counts * 100.0) / nsyms);
11945 }
11946 }
11947
11948 free (counts);
11949 free (lengths);
11950 }
11951
11952 if (buckets != NULL)
11953 {
11954 free (buckets);
11955 free (chains);
11956 }
11957
11958 if (do_histogram && gnubuckets != NULL)
11959 {
11960 unsigned long * lengths;
11961 unsigned long * counts;
11962 unsigned long hn;
11963 unsigned long maxlength = 0;
11964 unsigned long nzero_counts = 0;
11965 unsigned long nsyms = 0;
11966
11967 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11968 "(total of %lu bucket):\n",
11969 "\nHistogram for `.gnu.hash' bucket list length "
11970 "(total of %lu buckets):\n",
11971 (unsigned long) ngnubuckets),
11972 (unsigned long) ngnubuckets);
11973
11974 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11975 if (lengths == NULL)
11976 {
11977 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11978 return FALSE;
11979 }
11980
11981 printf (_(" Length Number %% of total Coverage\n"));
11982
11983 for (hn = 0; hn < ngnubuckets; ++hn)
11984 if (gnubuckets[hn] != 0)
11985 {
11986 bfd_vma off, length = 1;
11987
11988 for (off = gnubuckets[hn] - gnusymidx;
11989 /* PR 17531 file: 010-77222-0.004. */
11990 off < ngnuchains && (gnuchains[off] & 1) == 0;
11991 ++off)
11992 ++length;
11993 lengths[hn] = length;
11994 if (length > maxlength)
11995 maxlength = length;
11996 nsyms += length;
11997 }
11998
11999 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12000 if (counts == NULL)
12001 {
12002 free (lengths);
12003 error (_("Out of memory allocating space for gnu histogram counts\n"));
12004 return FALSE;
12005 }
12006
12007 for (hn = 0; hn < ngnubuckets; ++hn)
12008 ++counts[lengths[hn]];
12009
12010 if (ngnubuckets > 0)
12011 {
12012 unsigned long j;
12013 printf (" 0 %-10lu (%5.1f%%)\n",
12014 counts[0], (counts[0] * 100.0) / ngnubuckets);
12015 for (j = 1; j <= maxlength; ++j)
12016 {
12017 nzero_counts += counts[j] * j;
12018 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12019 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12020 (nzero_counts * 100.0) / nsyms);
12021 }
12022 }
12023
12024 free (counts);
12025 free (lengths);
12026 free (gnubuckets);
12027 free (gnuchains);
12028 }
12029
12030 return TRUE;
12031}
12032
12033static bfd_boolean
12034process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12035{
12036 unsigned int i;
12037
12038 if (dynamic_syminfo == NULL
12039 || !do_dynamic)
12040 /* No syminfo, this is ok. */
12041 return TRUE;
12042
12043 /* There better should be a dynamic symbol section. */
12044 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12045 return FALSE;
12046
12047 if (dynamic_addr)
12048 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12049 "contains %d entry:\n",
12050 "\nDynamic info segment at offset 0x%lx "
12051 "contains %d entries:\n",
12052 dynamic_syminfo_nent),
12053 dynamic_syminfo_offset, dynamic_syminfo_nent);
12054
12055 printf (_(" Num: Name BoundTo Flags\n"));
12056 for (i = 0; i < dynamic_syminfo_nent; ++i)
12057 {
12058 unsigned short int flags = dynamic_syminfo[i].si_flags;
12059
12060 printf ("%4d: ", i);
12061 if (i >= num_dynamic_syms)
12062 printf (_("<corrupt index>"));
12063 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12064 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12065 else
12066 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12067 putchar (' ');
12068
12069 switch (dynamic_syminfo[i].si_boundto)
12070 {
12071 case SYMINFO_BT_SELF:
12072 fputs ("SELF ", stdout);
12073 break;
12074 case SYMINFO_BT_PARENT:
12075 fputs ("PARENT ", stdout);
12076 break;
12077 default:
12078 if (dynamic_syminfo[i].si_boundto > 0
12079 && dynamic_syminfo[i].si_boundto < dynamic_nent
12080 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12081 {
12082 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12083 putchar (' ' );
12084 }
12085 else
12086 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12087 break;
12088 }
12089
12090 if (flags & SYMINFO_FLG_DIRECT)
12091 printf (" DIRECT");
12092 if (flags & SYMINFO_FLG_PASSTHRU)
12093 printf (" PASSTHRU");
12094 if (flags & SYMINFO_FLG_COPY)
12095 printf (" COPY");
12096 if (flags & SYMINFO_FLG_LAZYLOAD)
12097 printf (" LAZYLOAD");
12098
12099 puts ("");
12100 }
12101
12102 return TRUE;
12103}
12104
12105#define IN_RANGE(START,END,ADDR,OFF) \
12106 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12107
12108/* Check to see if the given reloc needs to be handled in a target specific
12109 manner. If so then process the reloc and return TRUE otherwise return
12110 FALSE.
12111
12112 If called with reloc == NULL, then this is a signal that reloc processing
12113 for the current section has finished, and any saved state should be
12114 discarded. */
12115
12116static bfd_boolean
12117target_specific_reloc_handling (Filedata * filedata,
12118 Elf_Internal_Rela * reloc,
12119 unsigned char * start,
12120 unsigned char * end,
12121 Elf_Internal_Sym * symtab,
12122 unsigned long num_syms)
12123{
12124 unsigned int reloc_type = 0;
12125 unsigned long sym_index = 0;
12126
12127 if (reloc)
12128 {
12129 reloc_type = get_reloc_type (filedata, reloc->r_info);
12130 sym_index = get_reloc_symindex (reloc->r_info);
12131 }
12132
12133 switch (filedata->file_header.e_machine)
12134 {
12135 case EM_MSP430:
12136 case EM_MSP430_OLD:
12137 {
12138 static Elf_Internal_Sym * saved_sym = NULL;
12139
12140 if (reloc == NULL)
12141 {
12142 saved_sym = NULL;
12143 return TRUE;
12144 }
12145
12146 switch (reloc_type)
12147 {
12148 case 10: /* R_MSP430_SYM_DIFF */
12149 if (uses_msp430x_relocs (filedata))
12150 break;
12151 /* Fall through. */
12152 case 21: /* R_MSP430X_SYM_DIFF */
12153 /* PR 21139. */
12154 if (sym_index >= num_syms)
12155 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12156 sym_index);
12157 else
12158 saved_sym = symtab + sym_index;
12159 return TRUE;
12160
12161 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12162 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12163 goto handle_sym_diff;
12164
12165 case 5: /* R_MSP430_16_BYTE */
12166 case 9: /* R_MSP430_8 */
12167 if (uses_msp430x_relocs (filedata))
12168 break;
12169 goto handle_sym_diff;
12170
12171 case 2: /* R_MSP430_ABS16 */
12172 case 15: /* R_MSP430X_ABS16 */
12173 if (! uses_msp430x_relocs (filedata))
12174 break;
12175 goto handle_sym_diff;
12176
12177 handle_sym_diff:
12178 if (saved_sym != NULL)
12179 {
12180 int reloc_size = reloc_type == 1 ? 4 : 2;
12181 bfd_vma value;
12182
12183 if (sym_index >= num_syms)
12184 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12185 sym_index);
12186 else
12187 {
12188 value = reloc->r_addend + (symtab[sym_index].st_value
12189 - saved_sym->st_value);
12190
12191 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12192 byte_put (start + reloc->r_offset, value, reloc_size);
12193 else
12194 /* PR 21137 */
12195 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12196 (long) reloc->r_offset);
12197 }
12198
12199 saved_sym = NULL;
12200 return TRUE;
12201 }
12202 break;
12203
12204 default:
12205 if (saved_sym != NULL)
12206 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12207 break;
12208 }
12209 break;
12210 }
12211
12212 case EM_MN10300:
12213 case EM_CYGNUS_MN10300:
12214 {
12215 static Elf_Internal_Sym * saved_sym = NULL;
12216
12217 if (reloc == NULL)
12218 {
12219 saved_sym = NULL;
12220 return TRUE;
12221 }
12222
12223 switch (reloc_type)
12224 {
12225 case 34: /* R_MN10300_ALIGN */
12226 return TRUE;
12227 case 33: /* R_MN10300_SYM_DIFF */
12228 if (sym_index >= num_syms)
12229 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12230 sym_index);
12231 else
12232 saved_sym = symtab + sym_index;
12233 return TRUE;
12234
12235 case 1: /* R_MN10300_32 */
12236 case 2: /* R_MN10300_16 */
12237 if (saved_sym != NULL)
12238 {
12239 int reloc_size = reloc_type == 1 ? 4 : 2;
12240 bfd_vma value;
12241
12242 if (sym_index >= num_syms)
12243 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12244 sym_index);
12245 else
12246 {
12247 value = reloc->r_addend + (symtab[sym_index].st_value
12248 - saved_sym->st_value);
12249
12250 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12251 byte_put (start + reloc->r_offset, value, reloc_size);
12252 else
12253 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12254 (long) reloc->r_offset);
12255 }
12256
12257 saved_sym = NULL;
12258 return TRUE;
12259 }
12260 break;
12261 default:
12262 if (saved_sym != NULL)
12263 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12264 break;
12265 }
12266 break;
12267 }
12268
12269 case EM_RL78:
12270 {
12271 static bfd_vma saved_sym1 = 0;
12272 static bfd_vma saved_sym2 = 0;
12273 static bfd_vma value;
12274
12275 if (reloc == NULL)
12276 {
12277 saved_sym1 = saved_sym2 = 0;
12278 return TRUE;
12279 }
12280
12281 switch (reloc_type)
12282 {
12283 case 0x80: /* R_RL78_SYM. */
12284 saved_sym1 = saved_sym2;
12285 if (sym_index >= num_syms)
12286 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12287 sym_index);
12288 else
12289 {
12290 saved_sym2 = symtab[sym_index].st_value;
12291 saved_sym2 += reloc->r_addend;
12292 }
12293 return TRUE;
12294
12295 case 0x83: /* R_RL78_OPsub. */
12296 value = saved_sym1 - saved_sym2;
12297 saved_sym2 = saved_sym1 = 0;
12298 return TRUE;
12299 break;
12300
12301 case 0x41: /* R_RL78_ABS32. */
12302 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12303 byte_put (start + reloc->r_offset, value, 4);
12304 else
12305 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12306 (long) reloc->r_offset);
12307 value = 0;
12308 return TRUE;
12309
12310 case 0x43: /* R_RL78_ABS16. */
12311 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12312 byte_put (start + reloc->r_offset, value, 2);
12313 else
12314 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12315 (long) reloc->r_offset);
12316 value = 0;
12317 return TRUE;
12318
12319 default:
12320 break;
12321 }
12322 break;
12323 }
12324 }
12325
12326 return FALSE;
12327}
12328
12329/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12330 DWARF debug sections. This is a target specific test. Note - we do not
12331 go through the whole including-target-headers-multiple-times route, (as
12332 we have already done with <elf/h8.h>) because this would become very
12333 messy and even then this function would have to contain target specific
12334 information (the names of the relocs instead of their numeric values).
12335 FIXME: This is not the correct way to solve this problem. The proper way
12336 is to have target specific reloc sizing and typing functions created by
12337 the reloc-macros.h header, in the same way that it already creates the
12338 reloc naming functions. */
12339
12340static bfd_boolean
12341is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12342{
12343 /* Please keep this table alpha-sorted for ease of visual lookup. */
12344 switch (filedata->file_header.e_machine)
12345 {
12346 case EM_386:
12347 case EM_IAMCU:
12348 return reloc_type == 1; /* R_386_32. */
12349 case EM_68K:
12350 return reloc_type == 1; /* R_68K_32. */
12351 case EM_860:
12352 return reloc_type == 1; /* R_860_32. */
12353 case EM_960:
12354 return reloc_type == 2; /* R_960_32. */
12355 case EM_AARCH64:
12356 return (reloc_type == 258
12357 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12358 case EM_ADAPTEVA_EPIPHANY:
12359 return reloc_type == 3;
12360 case EM_ALPHA:
12361 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12362 case EM_ARC:
12363 return reloc_type == 1; /* R_ARC_32. */
12364 case EM_ARC_COMPACT:
12365 case EM_ARC_COMPACT2:
12366 return reloc_type == 4; /* R_ARC_32. */
12367 case EM_ARM:
12368 return reloc_type == 2; /* R_ARM_ABS32 */
12369 case EM_AVR_OLD:
12370 case EM_AVR:
12371 return reloc_type == 1;
12372 case EM_BLACKFIN:
12373 return reloc_type == 0x12; /* R_byte4_data. */
12374 case EM_CRIS:
12375 return reloc_type == 3; /* R_CRIS_32. */
12376 case EM_CR16:
12377 return reloc_type == 3; /* R_CR16_NUM32. */
12378 case EM_CRX:
12379 return reloc_type == 15; /* R_CRX_NUM32. */
12380 case EM_CSKY:
12381 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12382 case EM_CYGNUS_FRV:
12383 return reloc_type == 1;
12384 case EM_CYGNUS_D10V:
12385 case EM_D10V:
12386 return reloc_type == 6; /* R_D10V_32. */
12387 case EM_CYGNUS_D30V:
12388 case EM_D30V:
12389 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12390 case EM_DLX:
12391 return reloc_type == 3; /* R_DLX_RELOC_32. */
12392 case EM_CYGNUS_FR30:
12393 case EM_FR30:
12394 return reloc_type == 3; /* R_FR30_32. */
12395 case EM_FT32:
12396 return reloc_type == 1; /* R_FT32_32. */
12397 case EM_H8S:
12398 case EM_H8_300:
12399 case EM_H8_300H:
12400 return reloc_type == 1; /* R_H8_DIR32. */
12401 case EM_IA_64:
12402 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12403 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12404 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12405 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12406 case EM_IP2K_OLD:
12407 case EM_IP2K:
12408 return reloc_type == 2; /* R_IP2K_32. */
12409 case EM_IQ2000:
12410 return reloc_type == 2; /* R_IQ2000_32. */
12411 case EM_LATTICEMICO32:
12412 return reloc_type == 3; /* R_LM32_32. */
12413 case EM_M32C_OLD:
12414 case EM_M32C:
12415 return reloc_type == 3; /* R_M32C_32. */
12416 case EM_M32R:
12417 return reloc_type == 34; /* R_M32R_32_RELA. */
12418 case EM_68HC11:
12419 case EM_68HC12:
12420 return reloc_type == 6; /* R_M68HC11_32. */
12421 case EM_S12Z:
12422 return reloc_type == 7 || /* R_S12Z_EXT32 */
12423 reloc_type == 6; /* R_S12Z_CW32. */
12424 case EM_MCORE:
12425 return reloc_type == 1; /* R_MCORE_ADDR32. */
12426 case EM_CYGNUS_MEP:
12427 return reloc_type == 4; /* R_MEP_32. */
12428 case EM_METAG:
12429 return reloc_type == 2; /* R_METAG_ADDR32. */
12430 case EM_MICROBLAZE:
12431 return reloc_type == 1; /* R_MICROBLAZE_32. */
12432 case EM_MIPS:
12433 return reloc_type == 2; /* R_MIPS_32. */
12434 case EM_MMIX:
12435 return reloc_type == 4; /* R_MMIX_32. */
12436 case EM_CYGNUS_MN10200:
12437 case EM_MN10200:
12438 return reloc_type == 1; /* R_MN10200_32. */
12439 case EM_CYGNUS_MN10300:
12440 case EM_MN10300:
12441 return reloc_type == 1; /* R_MN10300_32. */
12442 case EM_MOXIE:
12443 return reloc_type == 1; /* R_MOXIE_32. */
12444 case EM_MSP430_OLD:
12445 case EM_MSP430:
12446 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12447 case EM_MT:
12448 return reloc_type == 2; /* R_MT_32. */
12449 case EM_NDS32:
12450 return reloc_type == 20; /* R_NDS32_RELA. */
12451 case EM_ALTERA_NIOS2:
12452 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12453 case EM_NIOS32:
12454 return reloc_type == 1; /* R_NIOS_32. */
12455 case EM_OR1K:
12456 return reloc_type == 1; /* R_OR1K_32. */
12457 case EM_PARISC:
12458 return (reloc_type == 1 /* R_PARISC_DIR32. */
12459 || reloc_type == 2 /* R_PARISC_DIR21L. */
12460 || reloc_type == 41); /* R_PARISC_SECREL32. */
12461 case EM_PJ:
12462 case EM_PJ_OLD:
12463 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12464 case EM_PPC64:
12465 return reloc_type == 1; /* R_PPC64_ADDR32. */
12466 case EM_PPC:
12467 return reloc_type == 1; /* R_PPC_ADDR32. */
12468 case EM_TI_PRU:
12469 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12470 case EM_RISCV:
12471 return reloc_type == 1; /* R_RISCV_32. */
12472 case EM_RL78:
12473 return reloc_type == 1; /* R_RL78_DIR32. */
12474 case EM_RX:
12475 return reloc_type == 1; /* R_RX_DIR32. */
12476 case EM_S370:
12477 return reloc_type == 1; /* R_I370_ADDR31. */
12478 case EM_S390_OLD:
12479 case EM_S390:
12480 return reloc_type == 4; /* R_S390_32. */
12481 case EM_SCORE:
12482 return reloc_type == 8; /* R_SCORE_ABS32. */
12483 case EM_SH:
12484 return reloc_type == 1; /* R_SH_DIR32. */
12485 case EM_SPARC32PLUS:
12486 case EM_SPARCV9:
12487 case EM_SPARC:
12488 return reloc_type == 3 /* R_SPARC_32. */
12489 || reloc_type == 23; /* R_SPARC_UA32. */
12490 case EM_SPU:
12491 return reloc_type == 6; /* R_SPU_ADDR32 */
12492 case EM_TI_C6000:
12493 return reloc_type == 1; /* R_C6000_ABS32. */
12494 case EM_TILEGX:
12495 return reloc_type == 2; /* R_TILEGX_32. */
12496 case EM_TILEPRO:
12497 return reloc_type == 1; /* R_TILEPRO_32. */
12498 case EM_CYGNUS_V850:
12499 case EM_V850:
12500 return reloc_type == 6; /* R_V850_ABS32. */
12501 case EM_V800:
12502 return reloc_type == 0x33; /* R_V810_WORD. */
12503 case EM_VAX:
12504 return reloc_type == 1; /* R_VAX_32. */
12505 case EM_VISIUM:
12506 return reloc_type == 3; /* R_VISIUM_32. */
12507 case EM_WEBASSEMBLY:
12508 return reloc_type == 1; /* R_WASM32_32. */
12509 case EM_X86_64:
12510 case EM_L1OM:
12511 case EM_K1OM:
12512 return reloc_type == 10; /* R_X86_64_32. */
12513 case EM_XC16X:
12514 case EM_C166:
12515 return reloc_type == 3; /* R_XC16C_ABS_32. */
12516 case EM_XGATE:
12517 return reloc_type == 4; /* R_XGATE_32. */
12518 case EM_XSTORMY16:
12519 return reloc_type == 1; /* R_XSTROMY16_32. */
12520 case EM_XTENSA_OLD:
12521 case EM_XTENSA:
12522 return reloc_type == 1; /* R_XTENSA_32. */
12523 default:
12524 {
12525 static unsigned int prev_warn = 0;
12526
12527 /* Avoid repeating the same warning multiple times. */
12528 if (prev_warn != filedata->file_header.e_machine)
12529 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12530 filedata->file_header.e_machine);
12531 prev_warn = filedata->file_header.e_machine;
12532 return FALSE;
12533 }
12534 }
12535}
12536
12537/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12538 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12539
12540static bfd_boolean
12541is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12542{
12543 switch (filedata->file_header.e_machine)
12544 /* Please keep this table alpha-sorted for ease of visual lookup. */
12545 {
12546 case EM_386:
12547 case EM_IAMCU:
12548 return reloc_type == 2; /* R_386_PC32. */
12549 case EM_68K:
12550 return reloc_type == 4; /* R_68K_PC32. */
12551 case EM_AARCH64:
12552 return reloc_type == 261; /* R_AARCH64_PREL32 */
12553 case EM_ADAPTEVA_EPIPHANY:
12554 return reloc_type == 6;
12555 case EM_ALPHA:
12556 return reloc_type == 10; /* R_ALPHA_SREL32. */
12557 case EM_ARC_COMPACT:
12558 case EM_ARC_COMPACT2:
12559 return reloc_type == 49; /* R_ARC_32_PCREL. */
12560 case EM_ARM:
12561 return reloc_type == 3; /* R_ARM_REL32 */
12562 case EM_AVR_OLD:
12563 case EM_AVR:
12564 return reloc_type == 36; /* R_AVR_32_PCREL. */
12565 case EM_MICROBLAZE:
12566 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12567 case EM_OR1K:
12568 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12569 case EM_PARISC:
12570 return reloc_type == 9; /* R_PARISC_PCREL32. */
12571 case EM_PPC:
12572 return reloc_type == 26; /* R_PPC_REL32. */
12573 case EM_PPC64:
12574 return reloc_type == 26; /* R_PPC64_REL32. */
12575 case EM_RISCV:
12576 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12577 case EM_S390_OLD:
12578 case EM_S390:
12579 return reloc_type == 5; /* R_390_PC32. */
12580 case EM_SH:
12581 return reloc_type == 2; /* R_SH_REL32. */
12582 case EM_SPARC32PLUS:
12583 case EM_SPARCV9:
12584 case EM_SPARC:
12585 return reloc_type == 6; /* R_SPARC_DISP32. */
12586 case EM_SPU:
12587 return reloc_type == 13; /* R_SPU_REL32. */
12588 case EM_TILEGX:
12589 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12590 case EM_TILEPRO:
12591 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12592 case EM_VISIUM:
12593 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12594 case EM_X86_64:
12595 case EM_L1OM:
12596 case EM_K1OM:
12597 return reloc_type == 2; /* R_X86_64_PC32. */
12598 case EM_XTENSA_OLD:
12599 case EM_XTENSA:
12600 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12601 default:
12602 /* Do not abort or issue an error message here. Not all targets use
12603 pc-relative 32-bit relocs in their DWARF debug information and we
12604 have already tested for target coverage in is_32bit_abs_reloc. A
12605 more helpful warning message will be generated by apply_relocations
12606 anyway, so just return. */
12607 return FALSE;
12608 }
12609}
12610
12611/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12612 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12613
12614static bfd_boolean
12615is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12616{
12617 switch (filedata->file_header.e_machine)
12618 {
12619 case EM_AARCH64:
12620 return reloc_type == 257; /* R_AARCH64_ABS64. */
12621 case EM_ALPHA:
12622 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12623 case EM_IA_64:
12624 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12625 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12626 case EM_PARISC:
12627 return reloc_type == 80; /* R_PARISC_DIR64. */
12628 case EM_PPC64:
12629 return reloc_type == 38; /* R_PPC64_ADDR64. */
12630 case EM_RISCV:
12631 return reloc_type == 2; /* R_RISCV_64. */
12632 case EM_SPARC32PLUS:
12633 case EM_SPARCV9:
12634 case EM_SPARC:
12635 return reloc_type == 32 /* R_SPARC_64. */
12636 || reloc_type == 54; /* R_SPARC_UA64. */
12637 case EM_X86_64:
12638 case EM_L1OM:
12639 case EM_K1OM:
12640 return reloc_type == 1; /* R_X86_64_64. */
12641 case EM_S390_OLD:
12642 case EM_S390:
12643 return reloc_type == 22; /* R_S390_64. */
12644 case EM_TILEGX:
12645 return reloc_type == 1; /* R_TILEGX_64. */
12646 case EM_MIPS:
12647 return reloc_type == 18; /* R_MIPS_64. */
12648 default:
12649 return FALSE;
12650 }
12651}
12652
12653/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12654 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12655
12656static bfd_boolean
12657is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12658{
12659 switch (filedata->file_header.e_machine)
12660 {
12661 case EM_AARCH64:
12662 return reloc_type == 260; /* R_AARCH64_PREL64. */
12663 case EM_ALPHA:
12664 return reloc_type == 11; /* R_ALPHA_SREL64. */
12665 case EM_IA_64:
12666 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12667 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12668 case EM_PARISC:
12669 return reloc_type == 72; /* R_PARISC_PCREL64. */
12670 case EM_PPC64:
12671 return reloc_type == 44; /* R_PPC64_REL64. */
12672 case EM_SPARC32PLUS:
12673 case EM_SPARCV9:
12674 case EM_SPARC:
12675 return reloc_type == 46; /* R_SPARC_DISP64. */
12676 case EM_X86_64:
12677 case EM_L1OM:
12678 case EM_K1OM:
12679 return reloc_type == 24; /* R_X86_64_PC64. */
12680 case EM_S390_OLD:
12681 case EM_S390:
12682 return reloc_type == 23; /* R_S390_PC64. */
12683 case EM_TILEGX:
12684 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12685 default:
12686 return FALSE;
12687 }
12688}
12689
12690/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12691 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12692
12693static bfd_boolean
12694is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12695{
12696 switch (filedata->file_header.e_machine)
12697 {
12698 case EM_CYGNUS_MN10200:
12699 case EM_MN10200:
12700 return reloc_type == 4; /* R_MN10200_24. */
12701 case EM_FT32:
12702 return reloc_type == 5; /* R_FT32_20. */
12703 default:
12704 return FALSE;
12705 }
12706}
12707
12708/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12709 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12710
12711static bfd_boolean
12712is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12713{
12714 /* Please keep this table alpha-sorted for ease of visual lookup. */
12715 switch (filedata->file_header.e_machine)
12716 {
12717 case EM_ARC:
12718 case EM_ARC_COMPACT:
12719 case EM_ARC_COMPACT2:
12720 return reloc_type == 2; /* R_ARC_16. */
12721 case EM_ADAPTEVA_EPIPHANY:
12722 return reloc_type == 5;
12723 case EM_AVR_OLD:
12724 case EM_AVR:
12725 return reloc_type == 4; /* R_AVR_16. */
12726 case EM_CYGNUS_D10V:
12727 case EM_D10V:
12728 return reloc_type == 3; /* R_D10V_16. */
12729 case EM_FT32:
12730 return reloc_type == 2; /* R_FT32_16. */
12731 case EM_H8S:
12732 case EM_H8_300:
12733 case EM_H8_300H:
12734 return reloc_type == R_H8_DIR16;
12735 case EM_IP2K_OLD:
12736 case EM_IP2K:
12737 return reloc_type == 1; /* R_IP2K_16. */
12738 case EM_M32C_OLD:
12739 case EM_M32C:
12740 return reloc_type == 1; /* R_M32C_16 */
12741 case EM_CYGNUS_MN10200:
12742 case EM_MN10200:
12743 return reloc_type == 2; /* R_MN10200_16. */
12744 case EM_CYGNUS_MN10300:
12745 case EM_MN10300:
12746 return reloc_type == 2; /* R_MN10300_16. */
12747 case EM_MSP430:
12748 if (uses_msp430x_relocs (filedata))
12749 return reloc_type == 2; /* R_MSP430_ABS16. */
12750 /* Fall through. */
12751 case EM_MSP430_OLD:
12752 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12753 case EM_NDS32:
12754 return reloc_type == 19; /* R_NDS32_RELA. */
12755 case EM_ALTERA_NIOS2:
12756 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12757 case EM_NIOS32:
12758 return reloc_type == 9; /* R_NIOS_16. */
12759 case EM_OR1K:
12760 return reloc_type == 2; /* R_OR1K_16. */
12761 case EM_RISCV:
12762 return reloc_type == 55; /* R_RISCV_SET16. */
12763 case EM_TI_PRU:
12764 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12765 case EM_TI_C6000:
12766 return reloc_type == 2; /* R_C6000_ABS16. */
12767 case EM_VISIUM:
12768 return reloc_type == 2; /* R_VISIUM_16. */
12769 case EM_XC16X:
12770 case EM_C166:
12771 return reloc_type == 2; /* R_XC16C_ABS_16. */
12772 case EM_XGATE:
12773 return reloc_type == 3; /* R_XGATE_16. */
12774 default:
12775 return FALSE;
12776 }
12777}
12778
12779/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12780 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12781
12782static bfd_boolean
12783is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12784{
12785 switch (filedata->file_header.e_machine)
12786 {
12787 case EM_RISCV:
12788 return reloc_type == 54; /* R_RISCV_SET8. */
12789 default:
12790 return FALSE;
12791 }
12792}
12793
12794/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12795 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12796
12797static bfd_boolean
12798is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12799{
12800 switch (filedata->file_header.e_machine)
12801 {
12802 case EM_RISCV:
12803 return reloc_type == 53; /* R_RISCV_SET6. */
12804 default:
12805 return FALSE;
12806 }
12807}
12808
12809/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12810 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12811
12812static bfd_boolean
12813is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12814{
12815 /* Please keep this table alpha-sorted for ease of visual lookup. */
12816 switch (filedata->file_header.e_machine)
12817 {
12818 case EM_RISCV:
12819 return reloc_type == 35; /* R_RISCV_ADD32. */
12820 default:
12821 return FALSE;
12822 }
12823}
12824
12825/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12826 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12827
12828static bfd_boolean
12829is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12830{
12831 /* Please keep this table alpha-sorted for ease of visual lookup. */
12832 switch (filedata->file_header.e_machine)
12833 {
12834 case EM_RISCV:
12835 return reloc_type == 39; /* R_RISCV_SUB32. */
12836 default:
12837 return FALSE;
12838 }
12839}
12840
12841/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12842 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12843
12844static bfd_boolean
12845is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12846{
12847 /* Please keep this table alpha-sorted for ease of visual lookup. */
12848 switch (filedata->file_header.e_machine)
12849 {
12850 case EM_RISCV:
12851 return reloc_type == 36; /* R_RISCV_ADD64. */
12852 default:
12853 return FALSE;
12854 }
12855}
12856
12857/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12858 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12859
12860static bfd_boolean
12861is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12862{
12863 /* Please keep this table alpha-sorted for ease of visual lookup. */
12864 switch (filedata->file_header.e_machine)
12865 {
12866 case EM_RISCV:
12867 return reloc_type == 40; /* R_RISCV_SUB64. */
12868 default:
12869 return FALSE;
12870 }
12871}
12872
12873/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12874 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12875
12876static bfd_boolean
12877is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12878{
12879 /* Please keep this table alpha-sorted for ease of visual lookup. */
12880 switch (filedata->file_header.e_machine)
12881 {
12882 case EM_RISCV:
12883 return reloc_type == 34; /* R_RISCV_ADD16. */
12884 default:
12885 return FALSE;
12886 }
12887}
12888
12889/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12890 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12891
12892static bfd_boolean
12893is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12894{
12895 /* Please keep this table alpha-sorted for ease of visual lookup. */
12896 switch (filedata->file_header.e_machine)
12897 {
12898 case EM_RISCV:
12899 return reloc_type == 38; /* R_RISCV_SUB16. */
12900 default:
12901 return FALSE;
12902 }
12903}
12904
12905/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12906 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12907
12908static bfd_boolean
12909is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12910{
12911 /* Please keep this table alpha-sorted for ease of visual lookup. */
12912 switch (filedata->file_header.e_machine)
12913 {
12914 case EM_RISCV:
12915 return reloc_type == 33; /* R_RISCV_ADD8. */
12916 default:
12917 return FALSE;
12918 }
12919}
12920
12921/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12922 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12923
12924static bfd_boolean
12925is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12926{
12927 /* Please keep this table alpha-sorted for ease of visual lookup. */
12928 switch (filedata->file_header.e_machine)
12929 {
12930 case EM_RISCV:
12931 return reloc_type == 37; /* R_RISCV_SUB8. */
12932 default:
12933 return FALSE;
12934 }
12935}
12936
12937/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12938 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12939
12940static bfd_boolean
12941is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12942{
12943 switch (filedata->file_header.e_machine)
12944 {
12945 case EM_RISCV:
12946 return reloc_type == 52; /* R_RISCV_SUB6. */
12947 default:
12948 return FALSE;
12949 }
12950}
12951
12952/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12953 relocation entries (possibly formerly used for SHT_GROUP sections). */
12954
12955static bfd_boolean
12956is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12957{
12958 switch (filedata->file_header.e_machine)
12959 {
12960 case EM_386: /* R_386_NONE. */
12961 case EM_68K: /* R_68K_NONE. */
12962 case EM_ADAPTEVA_EPIPHANY:
12963 case EM_ALPHA: /* R_ALPHA_NONE. */
12964 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12965 case EM_ARC: /* R_ARC_NONE. */
12966 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12967 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12968 case EM_ARM: /* R_ARM_NONE. */
12969 case EM_C166: /* R_XC16X_NONE. */
12970 case EM_CRIS: /* R_CRIS_NONE. */
12971 case EM_FT32: /* R_FT32_NONE. */
12972 case EM_IA_64: /* R_IA64_NONE. */
12973 case EM_K1OM: /* R_X86_64_NONE. */
12974 case EM_L1OM: /* R_X86_64_NONE. */
12975 case EM_M32R: /* R_M32R_NONE. */
12976 case EM_MIPS: /* R_MIPS_NONE. */
12977 case EM_MN10300: /* R_MN10300_NONE. */
12978 case EM_MOXIE: /* R_MOXIE_NONE. */
12979 case EM_NIOS32: /* R_NIOS_NONE. */
12980 case EM_OR1K: /* R_OR1K_NONE. */
12981 case EM_PARISC: /* R_PARISC_NONE. */
12982 case EM_PPC64: /* R_PPC64_NONE. */
12983 case EM_PPC: /* R_PPC_NONE. */
12984 case EM_RISCV: /* R_RISCV_NONE. */
12985 case EM_S390: /* R_390_NONE. */
12986 case EM_S390_OLD:
12987 case EM_SH: /* R_SH_NONE. */
12988 case EM_SPARC32PLUS:
12989 case EM_SPARC: /* R_SPARC_NONE. */
12990 case EM_SPARCV9:
12991 case EM_TILEGX: /* R_TILEGX_NONE. */
12992 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12993 case EM_TI_C6000:/* R_C6000_NONE. */
12994 case EM_X86_64: /* R_X86_64_NONE. */
12995 case EM_XC16X:
12996 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12997 return reloc_type == 0;
12998
12999 case EM_AARCH64:
13000 return reloc_type == 0 || reloc_type == 256;
13001 case EM_AVR_OLD:
13002 case EM_AVR:
13003 return (reloc_type == 0 /* R_AVR_NONE. */
13004 || reloc_type == 30 /* R_AVR_DIFF8. */
13005 || reloc_type == 31 /* R_AVR_DIFF16. */
13006 || reloc_type == 32 /* R_AVR_DIFF32. */);
13007 case EM_METAG:
13008 return reloc_type == 3; /* R_METAG_NONE. */
13009 case EM_NDS32:
13010 return (reloc_type == 0 /* R_XTENSA_NONE. */
13011 || reloc_type == 204 /* R_NDS32_DIFF8. */
13012 || reloc_type == 205 /* R_NDS32_DIFF16. */
13013 || reloc_type == 206 /* R_NDS32_DIFF32. */
13014 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13015 case EM_TI_PRU:
13016 return (reloc_type == 0 /* R_PRU_NONE. */
13017 || reloc_type == 65 /* R_PRU_DIFF8. */
13018 || reloc_type == 66 /* R_PRU_DIFF16. */
13019 || reloc_type == 67 /* R_PRU_DIFF32. */);
13020 case EM_XTENSA_OLD:
13021 case EM_XTENSA:
13022 return (reloc_type == 0 /* R_XTENSA_NONE. */
13023 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13024 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13025 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13026 }
13027 return FALSE;
13028}
13029
13030/* Returns TRUE if there is a relocation against
13031 section NAME at OFFSET bytes. */
13032
13033bfd_boolean
13034reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13035{
13036 Elf_Internal_Rela * relocs;
13037 Elf_Internal_Rela * rp;
13038
13039 if (dsec == NULL || dsec->reloc_info == NULL)
13040 return FALSE;
13041
13042 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13043
13044 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13045 if (rp->r_offset == offset)
13046 return TRUE;
13047
13048 return FALSE;
13049}
13050
13051/* Apply relocations to a section.
13052 Returns TRUE upon success, FALSE otherwise.
13053 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13054 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13055 will be set to the number of relocs loaded.
13056
13057 Note: So far support has been added only for those relocations
13058 which can be found in debug sections. FIXME: Add support for
13059 more relocations ? */
13060
13061static bfd_boolean
13062apply_relocations (Filedata * filedata,
13063 const Elf_Internal_Shdr * section,
13064 unsigned char * start,
13065 bfd_size_type size,
13066 void ** relocs_return,
13067 unsigned long * num_relocs_return)
13068{
13069 Elf_Internal_Shdr * relsec;
13070 unsigned char * end = start + size;
13071
13072 if (relocs_return != NULL)
13073 {
13074 * (Elf_Internal_Rela **) relocs_return = NULL;
13075 * num_relocs_return = 0;
13076 }
13077
13078 if (filedata->file_header.e_type != ET_REL)
13079 /* No relocs to apply. */
13080 return TRUE;
13081
13082 /* Find the reloc section associated with the section. */
13083 for (relsec = filedata->section_headers;
13084 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13085 ++relsec)
13086 {
13087 bfd_boolean is_rela;
13088 unsigned long num_relocs;
13089 Elf_Internal_Rela * relocs;
13090 Elf_Internal_Rela * rp;
13091 Elf_Internal_Shdr * symsec;
13092 Elf_Internal_Sym * symtab;
13093 unsigned long num_syms;
13094 Elf_Internal_Sym * sym;
13095
13096 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13097 || relsec->sh_info >= filedata->file_header.e_shnum
13098 || filedata->section_headers + relsec->sh_info != section
13099 || relsec->sh_size == 0
13100 || relsec->sh_link >= filedata->file_header.e_shnum)
13101 continue;
13102
13103 is_rela = relsec->sh_type == SHT_RELA;
13104
13105 if (is_rela)
13106 {
13107 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13108 relsec->sh_size, & relocs, & num_relocs))
13109 return FALSE;
13110 }
13111 else
13112 {
13113 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13114 relsec->sh_size, & relocs, & num_relocs))
13115 return FALSE;
13116 }
13117
13118 /* SH uses RELA but uses in place value instead of the addend field. */
13119 if (filedata->file_header.e_machine == EM_SH)
13120 is_rela = FALSE;
13121
13122 symsec = filedata->section_headers + relsec->sh_link;
13123 if (symsec->sh_type != SHT_SYMTAB
13124 && symsec->sh_type != SHT_DYNSYM)
13125 return FALSE;
13126 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13127
13128 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13129 {
13130 bfd_vma addend;
13131 unsigned int reloc_type;
13132 unsigned int reloc_size;
13133 bfd_boolean reloc_inplace = FALSE;
13134 bfd_boolean reloc_subtract = FALSE;
13135 unsigned char * rloc;
13136 unsigned long sym_index;
13137
13138 reloc_type = get_reloc_type (filedata, rp->r_info);
13139
13140 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13141 continue;
13142 else if (is_none_reloc (filedata, reloc_type))
13143 continue;
13144 else if (is_32bit_abs_reloc (filedata, reloc_type)
13145 || is_32bit_pcrel_reloc (filedata, reloc_type))
13146 reloc_size = 4;
13147 else if (is_64bit_abs_reloc (filedata, reloc_type)
13148 || is_64bit_pcrel_reloc (filedata, reloc_type))
13149 reloc_size = 8;
13150 else if (is_24bit_abs_reloc (filedata, reloc_type))
13151 reloc_size = 3;
13152 else if (is_16bit_abs_reloc (filedata, reloc_type))
13153 reloc_size = 2;
13154 else if (is_8bit_abs_reloc (filedata, reloc_type)
13155 || is_6bit_abs_reloc (filedata, reloc_type))
13156 reloc_size = 1;
13157 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13158 reloc_type))
13159 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13160 {
13161 reloc_size = 4;
13162 reloc_inplace = TRUE;
13163 }
13164 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13165 reloc_type))
13166 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13167 {
13168 reloc_size = 8;
13169 reloc_inplace = TRUE;
13170 }
13171 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13172 reloc_type))
13173 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13174 {
13175 reloc_size = 2;
13176 reloc_inplace = TRUE;
13177 }
13178 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13179 reloc_type))
13180 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13181 {
13182 reloc_size = 1;
13183 reloc_inplace = TRUE;
13184 }
13185 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13186 reloc_type)))
13187 {
13188 reloc_size = 1;
13189 reloc_inplace = TRUE;
13190 }
13191 else
13192 {
13193 static unsigned int prev_reloc = 0;
13194
13195 if (reloc_type != prev_reloc)
13196 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13197 reloc_type, printable_section_name (filedata, section));
13198 prev_reloc = reloc_type;
13199 continue;
13200 }
13201
13202 rloc = start + rp->r_offset;
13203 if ((rloc + reloc_size) > end || (rloc < start))
13204 {
13205 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13206 (unsigned long) rp->r_offset,
13207 printable_section_name (filedata, section));
13208 continue;
13209 }
13210
13211 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13212 if (sym_index >= num_syms)
13213 {
13214 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13215 sym_index, printable_section_name (filedata, section));
13216 continue;
13217 }
13218 sym = symtab + sym_index;
13219
13220 /* If the reloc has a symbol associated with it,
13221 make sure that it is of an appropriate type.
13222
13223 Relocations against symbols without type can happen.
13224 Gcc -feliminate-dwarf2-dups may generate symbols
13225 without type for debug info.
13226
13227 Icc generates relocations against function symbols
13228 instead of local labels.
13229
13230 Relocations against object symbols can happen, eg when
13231 referencing a global array. For an example of this see
13232 the _clz.o binary in libgcc.a. */
13233 if (sym != symtab
13234 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13235 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13236 {
13237 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13238 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13239 printable_section_name (filedata, relsec),
13240 (long int)(rp - relocs));
13241 continue;
13242 }
13243
13244 addend = 0;
13245 if (is_rela)
13246 addend += rp->r_addend;
13247 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13248 partial_inplace. */
13249 if (!is_rela
13250 || (filedata->file_header.e_machine == EM_XTENSA
13251 && reloc_type == 1)
13252 || ((filedata->file_header.e_machine == EM_PJ
13253 || filedata->file_header.e_machine == EM_PJ_OLD)
13254 && reloc_type == 1)
13255 || ((filedata->file_header.e_machine == EM_D30V
13256 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13257 && reloc_type == 12)
13258 || reloc_inplace)
13259 {
13260 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13261 addend += byte_get (rloc, reloc_size) & 0x3f;
13262 else
13263 addend += byte_get (rloc, reloc_size);
13264 }
13265
13266 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13267 || is_64bit_pcrel_reloc (filedata, reloc_type))
13268 {
13269 /* On HPPA, all pc-relative relocations are biased by 8. */
13270 if (filedata->file_header.e_machine == EM_PARISC)
13271 addend -= 8;
13272 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13273 reloc_size);
13274 }
13275 else if (is_6bit_abs_reloc (filedata, reloc_type)
13276 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13277 {
13278 if (reloc_subtract)
13279 addend -= sym->st_value;
13280 else
13281 addend += sym->st_value;
13282 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13283 byte_put (rloc, addend, reloc_size);
13284 }
13285 else if (reloc_subtract)
13286 byte_put (rloc, addend - sym->st_value, reloc_size);
13287 else
13288 byte_put (rloc, addend + sym->st_value, reloc_size);
13289 }
13290
13291 free (symtab);
13292 /* Let the target specific reloc processing code know that
13293 we have finished with these relocs. */
13294 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13295
13296 if (relocs_return)
13297 {
13298 * (Elf_Internal_Rela **) relocs_return = relocs;
13299 * num_relocs_return = num_relocs;
13300 }
13301 else
13302 free (relocs);
13303
13304 break;
13305 }
13306
13307 return TRUE;
13308}
13309
13310#ifdef SUPPORT_DISASSEMBLY
13311static bfd_boolean
13312disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13313{
13314 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13315
13316 /* FIXME: XXX -- to be done --- XXX */
13317
13318 return TRUE;
13319}
13320#endif
13321
13322/* Reads in the contents of SECTION from FILE, returning a pointer
13323 to a malloc'ed buffer or NULL if something went wrong. */
13324
13325static char *
13326get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13327{
13328 bfd_size_type num_bytes = section->sh_size;
13329
13330 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13331 {
13332 printf (_("Section '%s' has no data to dump.\n"),
13333 printable_section_name (filedata, section));
13334 return NULL;
13335 }
13336
13337 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13338 _("section contents"));
13339}
13340
13341/* Uncompresses a section that was compressed using zlib, in place. */
13342
13343static bfd_boolean
13344uncompress_section_contents (unsigned char ** buffer,
13345 dwarf_size_type uncompressed_size,
13346 dwarf_size_type * size)
13347{
13348 dwarf_size_type compressed_size = *size;
13349 unsigned char * compressed_buffer = *buffer;
13350 unsigned char * uncompressed_buffer;
13351 z_stream strm;
13352 int rc;
13353
13354 /* It is possible the section consists of several compressed
13355 buffers concatenated together, so we uncompress in a loop. */
13356 /* PR 18313: The state field in the z_stream structure is supposed
13357 to be invisible to the user (ie us), but some compilers will
13358 still complain about it being used without initialisation. So
13359 we first zero the entire z_stream structure and then set the fields
13360 that we need. */
13361 memset (& strm, 0, sizeof strm);
13362 strm.avail_in = compressed_size;
13363 strm.next_in = (Bytef *) compressed_buffer;
13364 strm.avail_out = uncompressed_size;
13365 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13366
13367 rc = inflateInit (& strm);
13368 while (strm.avail_in > 0)
13369 {
13370 if (rc != Z_OK)
13371 goto fail;
13372 strm.next_out = ((Bytef *) uncompressed_buffer
13373 + (uncompressed_size - strm.avail_out));
13374 rc = inflate (&strm, Z_FINISH);
13375 if (rc != Z_STREAM_END)
13376 goto fail;
13377 rc = inflateReset (& strm);
13378 }
13379 rc = inflateEnd (& strm);
13380 if (rc != Z_OK
13381 || strm.avail_out != 0)
13382 goto fail;
13383
13384 *buffer = uncompressed_buffer;
13385 *size = uncompressed_size;
13386 return TRUE;
13387
13388 fail:
13389 free (uncompressed_buffer);
13390 /* Indicate decompression failure. */
13391 *buffer = NULL;
13392 return FALSE;
13393}
13394
13395static bfd_boolean
13396dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13397{
13398 Elf_Internal_Shdr * relsec;
13399 bfd_size_type num_bytes;
13400 unsigned char * data;
13401 unsigned char * end;
13402 unsigned char * real_start;
13403 unsigned char * start;
13404 bfd_boolean some_strings_shown;
13405
13406 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13407 if (start == NULL)
13408 /* PR 21820: Do not fail if the section was empty. */
13409 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13410
13411 num_bytes = section->sh_size;
13412
13413 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13414
13415 if (decompress_dumps)
13416 {
13417 dwarf_size_type new_size = num_bytes;
13418 dwarf_size_type uncompressed_size = 0;
13419
13420 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13421 {
13422 Elf_Internal_Chdr chdr;
13423 unsigned int compression_header_size
13424 = get_compression_header (& chdr, (unsigned char *) start,
13425 num_bytes);
13426
13427 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13428 {
13429 warn (_("section '%s' has unsupported compress type: %d\n"),
13430 printable_section_name (filedata, section), chdr.ch_type);
13431 return FALSE;
13432 }
13433 uncompressed_size = chdr.ch_size;
13434 start += compression_header_size;
13435 new_size -= compression_header_size;
13436 }
13437 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13438 {
13439 /* Read the zlib header. In this case, it should be "ZLIB"
13440 followed by the uncompressed section size, 8 bytes in
13441 big-endian order. */
13442 uncompressed_size = start[4]; uncompressed_size <<= 8;
13443 uncompressed_size += start[5]; uncompressed_size <<= 8;
13444 uncompressed_size += start[6]; uncompressed_size <<= 8;
13445 uncompressed_size += start[7]; uncompressed_size <<= 8;
13446 uncompressed_size += start[8]; uncompressed_size <<= 8;
13447 uncompressed_size += start[9]; uncompressed_size <<= 8;
13448 uncompressed_size += start[10]; uncompressed_size <<= 8;
13449 uncompressed_size += start[11];
13450 start += 12;
13451 new_size -= 12;
13452 }
13453
13454 if (uncompressed_size)
13455 {
13456 if (uncompress_section_contents (& start,
13457 uncompressed_size, & new_size))
13458 num_bytes = new_size;
13459 else
13460 {
13461 error (_("Unable to decompress section %s\n"),
13462 printable_section_name (filedata, section));
13463 return FALSE;
13464 }
13465 }
13466 else
13467 start = real_start;
13468 }
13469
13470 /* If the section being dumped has relocations against it the user might
13471 be expecting these relocations to have been applied. Check for this
13472 case and issue a warning message in order to avoid confusion.
13473 FIXME: Maybe we ought to have an option that dumps a section with
13474 relocs applied ? */
13475 for (relsec = filedata->section_headers;
13476 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13477 ++relsec)
13478 {
13479 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13480 || relsec->sh_info >= filedata->file_header.e_shnum
13481 || filedata->section_headers + relsec->sh_info != section
13482 || relsec->sh_size == 0
13483 || relsec->sh_link >= filedata->file_header.e_shnum)
13484 continue;
13485
13486 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13487 break;
13488 }
13489
13490 data = start;
13491 end = start + num_bytes;
13492 some_strings_shown = FALSE;
13493
13494 while (data < end)
13495 {
13496 while (!ISPRINT (* data))
13497 if (++ data >= end)
13498 break;
13499
13500 if (data < end)
13501 {
13502 size_t maxlen = end - data;
13503
13504#ifndef __MSVCRT__
13505 /* PR 11128: Use two separate invocations in order to work
13506 around bugs in the Solaris 8 implementation of printf. */
13507 printf (" [%6tx] ", data - start);
13508#else
13509 printf (" [%6Ix] ", (size_t) (data - start));
13510#endif
13511 if (maxlen > 0)
13512 {
13513 print_symbol ((int) maxlen, (const char *) data);
13514 putchar ('\n');
13515 data += strnlen ((const char *) data, maxlen);
13516 }
13517 else
13518 {
13519 printf (_("<corrupt>\n"));
13520 data = end;
13521 }
13522 some_strings_shown = TRUE;
13523 }
13524 }
13525
13526 if (! some_strings_shown)
13527 printf (_(" No strings found in this section."));
13528
13529 free (real_start);
13530
13531 putchar ('\n');
13532 return TRUE;
13533}
13534
13535static bfd_boolean
13536dump_section_as_bytes (Elf_Internal_Shdr * section,
13537 Filedata * filedata,
13538 bfd_boolean relocate)
13539{
13540 Elf_Internal_Shdr * relsec;
13541 bfd_size_type bytes;
13542 bfd_size_type section_size;
13543 bfd_vma addr;
13544 unsigned char * data;
13545 unsigned char * real_start;
13546 unsigned char * start;
13547
13548 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13549 if (start == NULL)
13550 /* PR 21820: Do not fail if the section was empty. */
13551 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13552
13553 section_size = section->sh_size;
13554
13555 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13556
13557 if (decompress_dumps)
13558 {
13559 dwarf_size_type new_size = section_size;
13560 dwarf_size_type uncompressed_size = 0;
13561
13562 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13563 {
13564 Elf_Internal_Chdr chdr;
13565 unsigned int compression_header_size
13566 = get_compression_header (& chdr, start, section_size);
13567
13568 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13569 {
13570 warn (_("section '%s' has unsupported compress type: %d\n"),
13571 printable_section_name (filedata, section), chdr.ch_type);
13572 return FALSE;
13573 }
13574 uncompressed_size = chdr.ch_size;
13575 start += compression_header_size;
13576 new_size -= compression_header_size;
13577 }
13578 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13579 {
13580 /* Read the zlib header. In this case, it should be "ZLIB"
13581 followed by the uncompressed section size, 8 bytes in
13582 big-endian order. */
13583 uncompressed_size = start[4]; uncompressed_size <<= 8;
13584 uncompressed_size += start[5]; uncompressed_size <<= 8;
13585 uncompressed_size += start[6]; uncompressed_size <<= 8;
13586 uncompressed_size += start[7]; uncompressed_size <<= 8;
13587 uncompressed_size += start[8]; uncompressed_size <<= 8;
13588 uncompressed_size += start[9]; uncompressed_size <<= 8;
13589 uncompressed_size += start[10]; uncompressed_size <<= 8;
13590 uncompressed_size += start[11];
13591 start += 12;
13592 new_size -= 12;
13593 }
13594
13595 if (uncompressed_size)
13596 {
13597 if (uncompress_section_contents (& start, uncompressed_size,
13598 & new_size))
13599 {
13600 section_size = new_size;
13601 }
13602 else
13603 {
13604 error (_("Unable to decompress section %s\n"),
13605 printable_section_name (filedata, section));
13606 /* FIXME: Print the section anyway ? */
13607 return FALSE;
13608 }
13609 }
13610 else
13611 start = real_start;
13612 }
13613
13614 if (relocate)
13615 {
13616 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13617 return FALSE;
13618 }
13619 else
13620 {
13621 /* If the section being dumped has relocations against it the user might
13622 be expecting these relocations to have been applied. Check for this
13623 case and issue a warning message in order to avoid confusion.
13624 FIXME: Maybe we ought to have an option that dumps a section with
13625 relocs applied ? */
13626 for (relsec = filedata->section_headers;
13627 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13628 ++relsec)
13629 {
13630 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13631 || relsec->sh_info >= filedata->file_header.e_shnum
13632 || filedata->section_headers + relsec->sh_info != section
13633 || relsec->sh_size == 0
13634 || relsec->sh_link >= filedata->file_header.e_shnum)
13635 continue;
13636
13637 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13638 break;
13639 }
13640 }
13641
13642 addr = section->sh_addr;
13643 bytes = section_size;
13644 data = start;
13645
13646 while (bytes)
13647 {
13648 int j;
13649 int k;
13650 int lbytes;
13651
13652 lbytes = (bytes > 16 ? 16 : bytes);
13653
13654 printf (" 0x%8.8lx ", (unsigned long) addr);
13655
13656 for (j = 0; j < 16; j++)
13657 {
13658 if (j < lbytes)
13659 printf ("%2.2x", data[j]);
13660 else
13661 printf (" ");
13662
13663 if ((j & 3) == 3)
13664 printf (" ");
13665 }
13666
13667 for (j = 0; j < lbytes; j++)
13668 {
13669 k = data[j];
13670 if (k >= ' ' && k < 0x7f)
13671 printf ("%c", k);
13672 else
13673 printf (".");
13674 }
13675
13676 putchar ('\n');
13677
13678 data += lbytes;
13679 addr += lbytes;
13680 bytes -= lbytes;
13681 }
13682
13683 free (real_start);
13684
13685 putchar ('\n');
13686 return TRUE;
13687}
13688
13689static bfd_boolean
13690load_specific_debug_section (enum dwarf_section_display_enum debug,
13691 const Elf_Internal_Shdr * sec,
13692 void * data)
13693{
13694 struct dwarf_section * section = &debug_displays [debug].section;
13695 char buf [64];
13696 Filedata * filedata = (Filedata *) data;
13697
13698 if (section->start != NULL)
13699 {
13700 /* If it is already loaded, do nothing. */
13701 if (streq (section->filename, filedata->file_name))
13702 return TRUE;
13703 free (section->start);
13704 }
13705
13706 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13707 section->address = sec->sh_addr;
13708 section->user_data = NULL;
13709 section->filename = filedata->file_name;
13710 section->start = (unsigned char *) get_data (NULL, filedata,
13711 sec->sh_offset, 1,
13712 sec->sh_size, buf);
13713 if (section->start == NULL)
13714 section->size = 0;
13715 else
13716 {
13717 unsigned char *start = section->start;
13718 dwarf_size_type size = sec->sh_size;
13719 dwarf_size_type uncompressed_size = 0;
13720
13721 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13722 {
13723 Elf_Internal_Chdr chdr;
13724 unsigned int compression_header_size;
13725
13726 if (size < (is_32bit_elf
13727 ? sizeof (Elf32_External_Chdr)
13728 : sizeof (Elf64_External_Chdr)))
13729 {
13730 warn (_("compressed section %s is too small to contain a compression header"),
13731 section->name);
13732 return FALSE;
13733 }
13734
13735 compression_header_size = get_compression_header (&chdr, start, size);
13736
13737 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13738 {
13739 warn (_("section '%s' has unsupported compress type: %d\n"),
13740 section->name, chdr.ch_type);
13741 return FALSE;
13742 }
13743 uncompressed_size = chdr.ch_size;
13744 start += compression_header_size;
13745 size -= compression_header_size;
13746 }
13747 else if (size > 12 && streq ((char *) start, "ZLIB"))
13748 {
13749 /* Read the zlib header. In this case, it should be "ZLIB"
13750 followed by the uncompressed section size, 8 bytes in
13751 big-endian order. */
13752 uncompressed_size = start[4]; uncompressed_size <<= 8;
13753 uncompressed_size += start[5]; uncompressed_size <<= 8;
13754 uncompressed_size += start[6]; uncompressed_size <<= 8;
13755 uncompressed_size += start[7]; uncompressed_size <<= 8;
13756 uncompressed_size += start[8]; uncompressed_size <<= 8;
13757 uncompressed_size += start[9]; uncompressed_size <<= 8;
13758 uncompressed_size += start[10]; uncompressed_size <<= 8;
13759 uncompressed_size += start[11];
13760 start += 12;
13761 size -= 12;
13762 }
13763
13764 if (uncompressed_size)
13765 {
13766 if (uncompress_section_contents (&start, uncompressed_size,
13767 &size))
13768 {
13769 /* Free the compressed buffer, update the section buffer
13770 and the section size if uncompress is successful. */
13771 free (section->start);
13772 section->start = start;
13773 }
13774 else
13775 {
13776 error (_("Unable to decompress section %s\n"),
13777 printable_section_name (filedata, sec));
13778 return FALSE;
13779 }
13780 }
13781
13782 section->size = size;
13783 }
13784
13785 if (section->start == NULL)
13786 return FALSE;
13787
13788 if (debug_displays [debug].relocate)
13789 {
13790 if (! apply_relocations (filedata, sec, section->start, section->size,
13791 & section->reloc_info, & section->num_relocs))
13792 return FALSE;
13793 }
13794 else
13795 {
13796 section->reloc_info = NULL;
13797 section->num_relocs = 0;
13798 }
13799
13800 return TRUE;
13801}
13802
13803/* If this is not NULL, load_debug_section will only look for sections
13804 within the list of sections given here. */
13805static unsigned int * section_subset = NULL;
13806
13807bfd_boolean
13808load_debug_section (enum dwarf_section_display_enum debug, void * data)
13809{
13810 struct dwarf_section * section = &debug_displays [debug].section;
13811 Elf_Internal_Shdr * sec;
13812 Filedata * filedata = (Filedata *) data;
13813
13814 /* Without section headers we cannot find any sections. */
13815 if (filedata->section_headers == NULL)
13816 return FALSE;
13817
13818 if (filedata->string_table == NULL
13819 && filedata->file_header.e_shstrndx != SHN_UNDEF
13820 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13821 {
13822 Elf_Internal_Shdr * strs;
13823
13824 /* Read in the string table, so that we have section names to scan. */
13825 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13826
13827 if (strs != NULL && strs->sh_size != 0)
13828 {
13829 filedata->string_table
13830 = (char *) get_data (NULL, filedata, strs->sh_offset,
13831 1, strs->sh_size, _("string table"));
13832
13833 filedata->string_table_length
13834 = filedata->string_table != NULL ? strs->sh_size : 0;
13835 }
13836 }
13837
13838 /* Locate the debug section. */
13839 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13840 if (sec != NULL)
13841 section->name = section->uncompressed_name;
13842 else
13843 {
13844 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13845 if (sec != NULL)
13846 section->name = section->compressed_name;
13847 }
13848 if (sec == NULL)
13849 return FALSE;
13850
13851 /* If we're loading from a subset of sections, and we've loaded
13852 a section matching this name before, it's likely that it's a
13853 different one. */
13854 if (section_subset != NULL)
13855 free_debug_section (debug);
13856
13857 return load_specific_debug_section (debug, sec, data);
13858}
13859
13860void
13861free_debug_section (enum dwarf_section_display_enum debug)
13862{
13863 struct dwarf_section * section = &debug_displays [debug].section;
13864
13865 if (section->start == NULL)
13866 return;
13867
13868 free ((char *) section->start);
13869 section->start = NULL;
13870 section->address = 0;
13871 section->size = 0;
13872}
13873
13874static bfd_boolean
13875display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13876{
13877 char * name = SECTION_NAME (section);
13878 const char * print_name = printable_section_name (filedata, section);
13879 bfd_size_type length;
13880 bfd_boolean result = TRUE;
13881 int i;
13882
13883 length = section->sh_size;
13884 if (length == 0)
13885 {
13886 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13887 return TRUE;
13888 }
13889 if (section->sh_type == SHT_NOBITS)
13890 {
13891 /* There is no point in dumping the contents of a debugging section
13892 which has the NOBITS type - the bits in the file will be random.
13893 This can happen when a file containing a .eh_frame section is
13894 stripped with the --only-keep-debug command line option. */
13895 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13896 print_name);
13897 return FALSE;
13898 }
13899
13900 if (const_strneq (name, ".gnu.linkonce.wi."))
13901 name = ".debug_info";
13902
13903 /* See if we know how to display the contents of this section. */
13904 for (i = 0; i < max; i++)
13905 {
13906 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
13907 struct dwarf_section_display * display = debug_displays + i;
13908 struct dwarf_section * sec = & display->section;
13909
13910 if (streq (sec->uncompressed_name, name)
13911 || (id == line && const_strneq (name, ".debug_line."))
13912 || streq (sec->compressed_name, name))
13913 {
13914 bfd_boolean secondary = (section != find_section (filedata, name));
13915
13916 if (secondary)
13917 free_debug_section (id);
13918
13919 if (i == line && const_strneq (name, ".debug_line."))
13920 sec->name = name;
13921 else if (streq (sec->uncompressed_name, name))
13922 sec->name = sec->uncompressed_name;
13923 else
13924 sec->name = sec->compressed_name;
13925
13926 if (load_specific_debug_section (id, section, filedata))
13927 {
13928 /* If this debug section is part of a CU/TU set in a .dwp file,
13929 restrict load_debug_section to the sections in that set. */
13930 section_subset = find_cu_tu_set (filedata, shndx);
13931
13932 result &= display->display (sec, filedata);
13933
13934 section_subset = NULL;
13935
13936 if (secondary || (id != info && id != abbrev))
13937 free_debug_section (id);
13938 }
13939 break;
13940 }
13941 }
13942
13943 if (i == max)
13944 {
13945 printf (_("Unrecognized debug section: %s\n"), print_name);
13946 result = FALSE;
13947 }
13948
13949 return result;
13950}
13951
13952/* Set DUMP_SECTS for all sections where dumps were requested
13953 based on section name. */
13954
13955static void
13956initialise_dumps_byname (Filedata * filedata)
13957{
13958 struct dump_list_entry * cur;
13959
13960 for (cur = dump_sects_byname; cur; cur = cur->next)
13961 {
13962 unsigned int i;
13963 bfd_boolean any = FALSE;
13964
13965 for (i = 0; i < filedata->file_header.e_shnum; i++)
13966 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13967 {
13968 request_dump_bynumber (filedata, i, cur->type);
13969 any = TRUE;
13970 }
13971
13972 if (!any)
13973 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13974 cur->name);
13975 }
13976}
13977
13978static bfd_boolean
13979process_section_contents (Filedata * filedata)
13980{
13981 Elf_Internal_Shdr * section;
13982 unsigned int i;
13983 bfd_boolean res = TRUE;
13984
13985 if (! do_dump)
13986 return TRUE;
13987
13988 initialise_dumps_byname (filedata);
13989
13990 for (i = 0, section = filedata->section_headers;
13991 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13992 i++, section++)
13993 {
13994 dump_type dump = filedata->dump_sects[i];
13995
13996#ifdef SUPPORT_DISASSEMBLY
13997 if (dump & DISASS_DUMP)
13998 {
13999 if (! disassemble_section (section, filedata))
14000 res = FALSE;
14001 }
14002#endif
14003 if (dump & HEX_DUMP)
14004 {
14005 if (! dump_section_as_bytes (section, filedata, FALSE))
14006 res = FALSE;
14007 }
14008
14009 if (dump & RELOC_DUMP)
14010 {
14011 if (! dump_section_as_bytes (section, filedata, TRUE))
14012 res = FALSE;
14013 }
14014
14015 if (dump & STRING_DUMP)
14016 {
14017 if (! dump_section_as_strings (section, filedata))
14018 res = FALSE;
14019 }
14020
14021 if (dump & DEBUG_DUMP)
14022 {
14023 if (! display_debug_section (i, section, filedata))
14024 res = FALSE;
14025 }
14026 }
14027
14028 /* Check to see if the user requested a
14029 dump of a section that does not exist. */
14030 while (i < filedata->num_dump_sects)
14031 {
14032 if (filedata->dump_sects[i])
14033 {
14034 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14035 res = FALSE;
14036 }
14037 i++;
14038 }
14039
14040 return res;
14041}
14042
14043static void
14044process_mips_fpe_exception (int mask)
14045{
14046 if (mask)
14047 {
14048 bfd_boolean first = TRUE;
14049
14050 if (mask & OEX_FPU_INEX)
14051 fputs ("INEX", stdout), first = FALSE;
14052 if (mask & OEX_FPU_UFLO)
14053 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14054 if (mask & OEX_FPU_OFLO)
14055 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14056 if (mask & OEX_FPU_DIV0)
14057 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14058 if (mask & OEX_FPU_INVAL)
14059 printf ("%sINVAL", first ? "" : "|");
14060 }
14061 else
14062 fputs ("0", stdout);
14063}
14064
14065/* Display's the value of TAG at location P. If TAG is
14066 greater than 0 it is assumed to be an unknown tag, and
14067 a message is printed to this effect. Otherwise it is
14068 assumed that a message has already been printed.
14069
14070 If the bottom bit of TAG is set it assumed to have a
14071 string value, otherwise it is assumed to have an integer
14072 value.
14073
14074 Returns an updated P pointing to the first unread byte
14075 beyond the end of TAG's value.
14076
14077 Reads at or beyond END will not be made. */
14078
14079static unsigned char *
14080display_tag_value (signed int tag,
14081 unsigned char * p,
14082 const unsigned char * const end)
14083{
14084 unsigned long val;
14085
14086 if (tag > 0)
14087 printf (" Tag_unknown_%d: ", tag);
14088
14089 if (p >= end)
14090 {
14091 warn (_("<corrupt tag>\n"));
14092 }
14093 else if (tag & 1)
14094 {
14095 /* PR 17531 file: 027-19978-0.004. */
14096 size_t maxlen = (end - p) - 1;
14097
14098 putchar ('"');
14099 if (maxlen > 0)
14100 {
14101 print_symbol ((int) maxlen, (const char *) p);
14102 p += strnlen ((char *) p, maxlen) + 1;
14103 }
14104 else
14105 {
14106 printf (_("<corrupt string tag>"));
14107 p = (unsigned char *) end;
14108 }
14109 printf ("\"\n");
14110 }
14111 else
14112 {
14113 unsigned int len;
14114
14115 val = read_uleb128 (p, &len, end);
14116 p += len;
14117 printf ("%ld (0x%lx)\n", val, val);
14118 }
14119
14120 assert (p <= end);
14121 return p;
14122}
14123
14124/* ARC ABI attributes section. */
14125
14126static unsigned char *
14127display_arc_attribute (unsigned char * p,
14128 const unsigned char * const end)
14129{
14130 unsigned int tag;
14131 unsigned int len;
14132 unsigned int val;
14133
14134 tag = read_uleb128 (p, &len, end);
14135 p += len;
14136
14137 switch (tag)
14138 {
14139 case Tag_ARC_PCS_config:
14140 val = read_uleb128 (p, &len, end);
14141 p += len;
14142 printf (" Tag_ARC_PCS_config: ");
14143 switch (val)
14144 {
14145 case 0:
14146 printf (_("Absent/Non standard\n"));
14147 break;
14148 case 1:
14149 printf (_("Bare metal/mwdt\n"));
14150 break;
14151 case 2:
14152 printf (_("Bare metal/newlib\n"));
14153 break;
14154 case 3:
14155 printf (_("Linux/uclibc\n"));
14156 break;
14157 case 4:
14158 printf (_("Linux/glibc\n"));
14159 break;
14160 default:
14161 printf (_("Unknown\n"));
14162 break;
14163 }
14164 break;
14165
14166 case Tag_ARC_CPU_base:
14167 val = read_uleb128 (p, &len, end);
14168 p += len;
14169 printf (" Tag_ARC_CPU_base: ");
14170 switch (val)
14171 {
14172 default:
14173 case TAG_CPU_NONE:
14174 printf (_("Absent\n"));
14175 break;
14176 case TAG_CPU_ARC6xx:
14177 printf ("ARC6xx\n");
14178 break;
14179 case TAG_CPU_ARC7xx:
14180 printf ("ARC7xx\n");
14181 break;
14182 case TAG_CPU_ARCEM:
14183 printf ("ARCEM\n");
14184 break;
14185 case TAG_CPU_ARCHS:
14186 printf ("ARCHS\n");
14187 break;
14188 }
14189 break;
14190
14191 case Tag_ARC_CPU_variation:
14192 val = read_uleb128 (p, &len, end);
14193 p += len;
14194 printf (" Tag_ARC_CPU_variation: ");
14195 switch (val)
14196 {
14197 default:
14198 if (val > 0 && val < 16)
14199 printf ("Core%d\n", val);
14200 else
14201 printf ("Unknown\n");
14202 break;
14203
14204 case 0:
14205 printf (_("Absent\n"));
14206 break;
14207 }
14208 break;
14209
14210 case Tag_ARC_CPU_name:
14211 printf (" Tag_ARC_CPU_name: ");
14212 p = display_tag_value (-1, p, end);
14213 break;
14214
14215 case Tag_ARC_ABI_rf16:
14216 val = read_uleb128 (p, &len, end);
14217 p += len;
14218 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14219 break;
14220
14221 case Tag_ARC_ABI_osver:
14222 val = read_uleb128 (p, &len, end);
14223 p += len;
14224 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14225 break;
14226
14227 case Tag_ARC_ABI_pic:
14228 case Tag_ARC_ABI_sda:
14229 val = read_uleb128 (p, &len, end);
14230 p += len;
14231 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14232 : " Tag_ARC_ABI_pic: ");
14233 switch (val)
14234 {
14235 case 0:
14236 printf (_("Absent\n"));
14237 break;
14238 case 1:
14239 printf ("MWDT\n");
14240 break;
14241 case 2:
14242 printf ("GNU\n");
14243 break;
14244 default:
14245 printf (_("Unknown\n"));
14246 break;
14247 }
14248 break;
14249
14250 case Tag_ARC_ABI_tls:
14251 val = read_uleb128 (p, &len, end);
14252 p += len;
14253 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14254 break;
14255
14256 case Tag_ARC_ABI_enumsize:
14257 val = read_uleb128 (p, &len, end);
14258 p += len;
14259 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14260 _("smallest"));
14261 break;
14262
14263 case Tag_ARC_ABI_exceptions:
14264 val = read_uleb128 (p, &len, end);
14265 p += len;
14266 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14267 : _("default"));
14268 break;
14269
14270 case Tag_ARC_ABI_double_size:
14271 val = read_uleb128 (p, &len, end);
14272 p += len;
14273 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14274 break;
14275
14276 case Tag_ARC_ISA_config:
14277 printf (" Tag_ARC_ISA_config: ");
14278 p = display_tag_value (-1, p, end);
14279 break;
14280
14281 case Tag_ARC_ISA_apex:
14282 printf (" Tag_ARC_ISA_apex: ");
14283 p = display_tag_value (-1, p, end);
14284 break;
14285
14286 case Tag_ARC_ISA_mpy_option:
14287 val = read_uleb128 (p, &len, end);
14288 p += len;
14289 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14290 break;
14291
14292 case Tag_ARC_ATR_version:
14293 val = read_uleb128 (p, &len, end);
14294 p += len;
14295 printf (" Tag_ARC_ATR_version: %d\n", val);
14296 break;
14297
14298 default:
14299 return display_tag_value (tag & 1, p, end);
14300 }
14301
14302 return p;
14303}
14304
14305/* ARM EABI attributes section. */
14306typedef struct
14307{
14308 unsigned int tag;
14309 const char * name;
14310 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14311 unsigned int type;
14312 const char ** table;
14313} arm_attr_public_tag;
14314
14315static const char * arm_attr_tag_CPU_arch[] =
14316 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14317 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14318 "v8-M.mainline"};
14319static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14320static const char * arm_attr_tag_THUMB_ISA_use[] =
14321 {"No", "Thumb-1", "Thumb-2", "Yes"};
14322static const char * arm_attr_tag_FP_arch[] =
14323 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14324 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14325static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14326static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14327 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14328 "NEON for ARMv8.1"};
14329static const char * arm_attr_tag_PCS_config[] =
14330 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14331 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14332static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14333 {"V6", "SB", "TLS", "Unused"};
14334static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14335 {"Absolute", "PC-relative", "SB-relative", "None"};
14336static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14337 {"Absolute", "PC-relative", "None"};
14338static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14339 {"None", "direct", "GOT-indirect"};
14340static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14341 {"None", "??? 1", "2", "??? 3", "4"};
14342static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14343static const char * arm_attr_tag_ABI_FP_denormal[] =
14344 {"Unused", "Needed", "Sign only"};
14345static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14346static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14347static const char * arm_attr_tag_ABI_FP_number_model[] =
14348 {"Unused", "Finite", "RTABI", "IEEE 754"};
14349static const char * arm_attr_tag_ABI_enum_size[] =
14350 {"Unused", "small", "int", "forced to int"};
14351static const char * arm_attr_tag_ABI_HardFP_use[] =
14352 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14353static const char * arm_attr_tag_ABI_VFP_args[] =
14354 {"AAPCS", "VFP registers", "custom", "compatible"};
14355static const char * arm_attr_tag_ABI_WMMX_args[] =
14356 {"AAPCS", "WMMX registers", "custom"};
14357static const char * arm_attr_tag_ABI_optimization_goals[] =
14358 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14359 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14360static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14361 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14362 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14363static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14364static const char * arm_attr_tag_FP_HP_extension[] =
14365 {"Not Allowed", "Allowed"};
14366static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14367 {"None", "IEEE 754", "Alternative Format"};
14368static const char * arm_attr_tag_DSP_extension[] =
14369 {"Follow architecture", "Allowed"};
14370static const char * arm_attr_tag_MPextension_use[] =
14371 {"Not Allowed", "Allowed"};
14372static const char * arm_attr_tag_DIV_use[] =
14373 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14374 "Allowed in v7-A with integer division extension"};
14375static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14376static const char * arm_attr_tag_Virtualization_use[] =
14377 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14378 "TrustZone and Virtualization Extensions"};
14379static const char * arm_attr_tag_MPextension_use_legacy[] =
14380 {"Not Allowed", "Allowed"};
14381
14382#define LOOKUP(id, name) \
14383 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14384static arm_attr_public_tag arm_attr_public_tags[] =
14385{
14386 {4, "CPU_raw_name", 1, NULL},
14387 {5, "CPU_name", 1, NULL},
14388 LOOKUP(6, CPU_arch),
14389 {7, "CPU_arch_profile", 0, NULL},
14390 LOOKUP(8, ARM_ISA_use),
14391 LOOKUP(9, THUMB_ISA_use),
14392 LOOKUP(10, FP_arch),
14393 LOOKUP(11, WMMX_arch),
14394 LOOKUP(12, Advanced_SIMD_arch),
14395 LOOKUP(13, PCS_config),
14396 LOOKUP(14, ABI_PCS_R9_use),
14397 LOOKUP(15, ABI_PCS_RW_data),
14398 LOOKUP(16, ABI_PCS_RO_data),
14399 LOOKUP(17, ABI_PCS_GOT_use),
14400 LOOKUP(18, ABI_PCS_wchar_t),
14401 LOOKUP(19, ABI_FP_rounding),
14402 LOOKUP(20, ABI_FP_denormal),
14403 LOOKUP(21, ABI_FP_exceptions),
14404 LOOKUP(22, ABI_FP_user_exceptions),
14405 LOOKUP(23, ABI_FP_number_model),
14406 {24, "ABI_align_needed", 0, NULL},
14407 {25, "ABI_align_preserved", 0, NULL},
14408 LOOKUP(26, ABI_enum_size),
14409 LOOKUP(27, ABI_HardFP_use),
14410 LOOKUP(28, ABI_VFP_args),
14411 LOOKUP(29, ABI_WMMX_args),
14412 LOOKUP(30, ABI_optimization_goals),
14413 LOOKUP(31, ABI_FP_optimization_goals),
14414 {32, "compatibility", 0, NULL},
14415 LOOKUP(34, CPU_unaligned_access),
14416 LOOKUP(36, FP_HP_extension),
14417 LOOKUP(38, ABI_FP_16bit_format),
14418 LOOKUP(42, MPextension_use),
14419 LOOKUP(44, DIV_use),
14420 LOOKUP(46, DSP_extension),
14421 {64, "nodefaults", 0, NULL},
14422 {65, "also_compatible_with", 0, NULL},
14423 LOOKUP(66, T2EE_use),
14424 {67, "conformance", 1, NULL},
14425 LOOKUP(68, Virtualization_use),
14426 LOOKUP(70, MPextension_use_legacy)
14427};
14428#undef LOOKUP
14429
14430static unsigned char *
14431display_arm_attribute (unsigned char * p,
14432 const unsigned char * const end)
14433{
14434 unsigned int tag;
14435 unsigned int len;
14436 unsigned int val;
14437 arm_attr_public_tag * attr;
14438 unsigned i;
14439 unsigned int type;
14440
14441 tag = read_uleb128 (p, &len, end);
14442 p += len;
14443 attr = NULL;
14444 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14445 {
14446 if (arm_attr_public_tags[i].tag == tag)
14447 {
14448 attr = &arm_attr_public_tags[i];
14449 break;
14450 }
14451 }
14452
14453 if (attr)
14454 {
14455 printf (" Tag_%s: ", attr->name);
14456 switch (attr->type)
14457 {
14458 case 0:
14459 switch (tag)
14460 {
14461 case 7: /* Tag_CPU_arch_profile. */
14462 val = read_uleb128 (p, &len, end);
14463 p += len;
14464 switch (val)
14465 {
14466 case 0: printf (_("None\n")); break;
14467 case 'A': printf (_("Application\n")); break;
14468 case 'R': printf (_("Realtime\n")); break;
14469 case 'M': printf (_("Microcontroller\n")); break;
14470 case 'S': printf (_("Application or Realtime\n")); break;
14471 default: printf ("??? (%d)\n", val); break;
14472 }
14473 break;
14474
14475 case 24: /* Tag_align_needed. */
14476 val = read_uleb128 (p, &len, end);
14477 p += len;
14478 switch (val)
14479 {
14480 case 0: printf (_("None\n")); break;
14481 case 1: printf (_("8-byte\n")); break;
14482 case 2: printf (_("4-byte\n")); break;
14483 case 3: printf ("??? 3\n"); break;
14484 default:
14485 if (val <= 12)
14486 printf (_("8-byte and up to %d-byte extended\n"),
14487 1 << val);
14488 else
14489 printf ("??? (%d)\n", val);
14490 break;
14491 }
14492 break;
14493
14494 case 25: /* Tag_align_preserved. */
14495 val = read_uleb128 (p, &len, end);
14496 p += len;
14497 switch (val)
14498 {
14499 case 0: printf (_("None\n")); break;
14500 case 1: printf (_("8-byte, except leaf SP\n")); break;
14501 case 2: printf (_("8-byte\n")); break;
14502 case 3: printf ("??? 3\n"); break;
14503 default:
14504 if (val <= 12)
14505 printf (_("8-byte and up to %d-byte extended\n"),
14506 1 << val);
14507 else
14508 printf ("??? (%d)\n", val);
14509 break;
14510 }
14511 break;
14512
14513 case 32: /* Tag_compatibility. */
14514 {
14515 val = read_uleb128 (p, &len, end);
14516 p += len;
14517 printf (_("flag = %d, vendor = "), val);
14518 if (p < end - 1)
14519 {
14520 size_t maxlen = (end - p) - 1;
14521
14522 print_symbol ((int) maxlen, (const char *) p);
14523 p += strnlen ((char *) p, maxlen) + 1;
14524 }
14525 else
14526 {
14527 printf (_("<corrupt>"));
14528 p = (unsigned char *) end;
14529 }
14530 putchar ('\n');
14531 }
14532 break;
14533
14534 case 64: /* Tag_nodefaults. */
14535 /* PR 17531: file: 001-505008-0.01. */
14536 if (p < end)
14537 p++;
14538 printf (_("True\n"));
14539 break;
14540
14541 case 65: /* Tag_also_compatible_with. */
14542 val = read_uleb128 (p, &len, end);
14543 p += len;
14544 if (val == 6 /* Tag_CPU_arch. */)
14545 {
14546 val = read_uleb128 (p, &len, end);
14547 p += len;
14548 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14549 printf ("??? (%d)\n", val);
14550 else
14551 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14552 }
14553 else
14554 printf ("???\n");
14555 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14556 ;
14557 break;
14558
14559 default:
14560 printf (_("<unknown: %d>\n"), tag);
14561 break;
14562 }
14563 return p;
14564
14565 case 1:
14566 return display_tag_value (-1, p, end);
14567 case 2:
14568 return display_tag_value (0, p, end);
14569
14570 default:
14571 assert (attr->type & 0x80);
14572 val = read_uleb128 (p, &len, end);
14573 p += len;
14574 type = attr->type & 0x7f;
14575 if (val >= type)
14576 printf ("??? (%d)\n", val);
14577 else
14578 printf ("%s\n", attr->table[val]);
14579 return p;
14580 }
14581 }
14582
14583 return display_tag_value (tag, p, end);
14584}
14585
14586static unsigned char *
14587display_gnu_attribute (unsigned char * p,
14588 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14589 const unsigned char * const end)
14590{
14591 int tag;
14592 unsigned int len;
14593 unsigned int val;
14594
14595 tag = read_uleb128 (p, &len, end);
14596 p += len;
14597
14598 /* Tag_compatibility is the only generic GNU attribute defined at
14599 present. */
14600 if (tag == 32)
14601 {
14602 val = read_uleb128 (p, &len, end);
14603 p += len;
14604
14605 printf (_("flag = %d, vendor = "), val);
14606 if (p == end)
14607 {
14608 printf (_("<corrupt>\n"));
14609 warn (_("corrupt vendor attribute\n"));
14610 }
14611 else
14612 {
14613 if (p < end - 1)
14614 {
14615 size_t maxlen = (end - p) - 1;
14616
14617 print_symbol ((int) maxlen, (const char *) p);
14618 p += strnlen ((char *) p, maxlen) + 1;
14619 }
14620 else
14621 {
14622 printf (_("<corrupt>"));
14623 p = (unsigned char *) end;
14624 }
14625 putchar ('\n');
14626 }
14627 return p;
14628 }
14629
14630 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14631 return display_proc_gnu_attribute (p, tag, end);
14632
14633 return display_tag_value (tag, p, end);
14634}
14635
14636static unsigned char *
14637display_power_gnu_attribute (unsigned char * p,
14638 unsigned int tag,
14639 const unsigned char * const end)
14640{
14641 unsigned int len;
14642 unsigned int val;
14643
14644 if (tag == Tag_GNU_Power_ABI_FP)
14645 {
14646 val = read_uleb128 (p, &len, end);
14647 p += len;
14648 printf (" Tag_GNU_Power_ABI_FP: ");
14649 if (len == 0)
14650 {
14651 printf (_("<corrupt>\n"));
14652 return p;
14653 }
14654
14655 if (val > 15)
14656 printf ("(%#x), ", val);
14657
14658 switch (val & 3)
14659 {
14660 case 0:
14661 printf (_("unspecified hard/soft float, "));
14662 break;
14663 case 1:
14664 printf (_("hard float, "));
14665 break;
14666 case 2:
14667 printf (_("soft float, "));
14668 break;
14669 case 3:
14670 printf (_("single-precision hard float, "));
14671 break;
14672 }
14673
14674 switch (val & 0xC)
14675 {
14676 case 0:
14677 printf (_("unspecified long double\n"));
14678 break;
14679 case 4:
14680 printf (_("128-bit IBM long double\n"));
14681 break;
14682 case 8:
14683 printf (_("64-bit long double\n"));
14684 break;
14685 case 12:
14686 printf (_("128-bit IEEE long double\n"));
14687 break;
14688 }
14689 return p;
14690 }
14691
14692 if (tag == Tag_GNU_Power_ABI_Vector)
14693 {
14694 val = read_uleb128 (p, &len, end);
14695 p += len;
14696 printf (" Tag_GNU_Power_ABI_Vector: ");
14697 if (len == 0)
14698 {
14699 printf (_("<corrupt>\n"));
14700 return p;
14701 }
14702
14703 if (val > 3)
14704 printf ("(%#x), ", val);
14705
14706 switch (val & 3)
14707 {
14708 case 0:
14709 printf (_("unspecified\n"));
14710 break;
14711 case 1:
14712 printf (_("generic\n"));
14713 break;
14714 case 2:
14715 printf ("AltiVec\n");
14716 break;
14717 case 3:
14718 printf ("SPE\n");
14719 break;
14720 }
14721 return p;
14722 }
14723
14724 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14725 {
14726 val = read_uleb128 (p, &len, end);
14727 p += len;
14728 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14729 if (len == 0)
14730 {
14731 printf (_("<corrupt>\n"));
14732 return p;
14733 }
14734
14735 if (val > 2)
14736 printf ("(%#x), ", val);
14737
14738 switch (val & 3)
14739 {
14740 case 0:
14741 printf (_("unspecified\n"));
14742 break;
14743 case 1:
14744 printf ("r3/r4\n");
14745 break;
14746 case 2:
14747 printf (_("memory\n"));
14748 break;
14749 case 3:
14750 printf ("???\n");
14751 break;
14752 }
14753 return p;
14754 }
14755
14756 return display_tag_value (tag & 1, p, end);
14757}
14758
14759static unsigned char *
14760display_s390_gnu_attribute (unsigned char * p,
14761 unsigned int tag,
14762 const unsigned char * const end)
14763{
14764 unsigned int len;
14765 int val;
14766
14767 if (tag == Tag_GNU_S390_ABI_Vector)
14768 {
14769 val = read_uleb128 (p, &len, end);
14770 p += len;
14771 printf (" Tag_GNU_S390_ABI_Vector: ");
14772
14773 switch (val)
14774 {
14775 case 0:
14776 printf (_("any\n"));
14777 break;
14778 case 1:
14779 printf (_("software\n"));
14780 break;
14781 case 2:
14782 printf (_("hardware\n"));
14783 break;
14784 default:
14785 printf ("??? (%d)\n", val);
14786 break;
14787 }
14788 return p;
14789 }
14790
14791 return display_tag_value (tag & 1, p, end);
14792}
14793
14794static void
14795display_sparc_hwcaps (unsigned int mask)
14796{
14797 if (mask)
14798 {
14799 bfd_boolean first = TRUE;
14800
14801 if (mask & ELF_SPARC_HWCAP_MUL32)
14802 fputs ("mul32", stdout), first = FALSE;
14803 if (mask & ELF_SPARC_HWCAP_DIV32)
14804 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14805 if (mask & ELF_SPARC_HWCAP_FSMULD)
14806 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14807 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14808 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14809 if (mask & ELF_SPARC_HWCAP_POPC)
14810 printf ("%spopc", first ? "" : "|"), first = FALSE;
14811 if (mask & ELF_SPARC_HWCAP_VIS)
14812 printf ("%svis", first ? "" : "|"), first = FALSE;
14813 if (mask & ELF_SPARC_HWCAP_VIS2)
14814 printf ("%svis2", first ? "" : "|"), first = FALSE;
14815 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14816 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14817 if (mask & ELF_SPARC_HWCAP_FMAF)
14818 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14819 if (mask & ELF_SPARC_HWCAP_VIS3)
14820 printf ("%svis3", first ? "" : "|"), first = FALSE;
14821 if (mask & ELF_SPARC_HWCAP_HPC)
14822 printf ("%shpc", first ? "" : "|"), first = FALSE;
14823 if (mask & ELF_SPARC_HWCAP_RANDOM)
14824 printf ("%srandom", first ? "" : "|"), first = FALSE;
14825 if (mask & ELF_SPARC_HWCAP_TRANS)
14826 printf ("%strans", first ? "" : "|"), first = FALSE;
14827 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14828 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14829 if (mask & ELF_SPARC_HWCAP_IMA)
14830 printf ("%sima", first ? "" : "|"), first = FALSE;
14831 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14832 printf ("%scspare", first ? "" : "|"), first = FALSE;
14833 }
14834 else
14835 fputc ('0', stdout);
14836 fputc ('\n', stdout);
14837}
14838
14839static void
14840display_sparc_hwcaps2 (unsigned int mask)
14841{
14842 if (mask)
14843 {
14844 bfd_boolean first = TRUE;
14845
14846 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14847 fputs ("fjathplus", stdout), first = FALSE;
14848 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14849 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14850 if (mask & ELF_SPARC_HWCAP2_ADP)
14851 printf ("%sadp", first ? "" : "|"), first = FALSE;
14852 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14853 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14854 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14855 printf ("%smwait", first ? "" : "|"), first = FALSE;
14856 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14857 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14858 if (mask & ELF_SPARC_HWCAP2_XMONT)
14859 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14860 if (mask & ELF_SPARC_HWCAP2_NSEC)
14861 printf ("%snsec", first ? "" : "|"), first = FALSE;
14862 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14863 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14864 if (mask & ELF_SPARC_HWCAP2_FJDES)
14865 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14866 if (mask & ELF_SPARC_HWCAP2_FJAES)
14867 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14868 }
14869 else
14870 fputc ('0', stdout);
14871 fputc ('\n', stdout);
14872}
14873
14874static unsigned char *
14875display_sparc_gnu_attribute (unsigned char * p,
14876 unsigned int tag,
14877 const unsigned char * const end)
14878{
14879 unsigned int len;
14880 int val;
14881
14882 if (tag == Tag_GNU_Sparc_HWCAPS)
14883 {
14884 val = read_uleb128 (p, &len, end);
14885 p += len;
14886 printf (" Tag_GNU_Sparc_HWCAPS: ");
14887 display_sparc_hwcaps (val);
14888 return p;
14889 }
14890 if (tag == Tag_GNU_Sparc_HWCAPS2)
14891 {
14892 val = read_uleb128 (p, &len, end);
14893 p += len;
14894 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14895 display_sparc_hwcaps2 (val);
14896 return p;
14897 }
14898
14899 return display_tag_value (tag, p, end);
14900}
14901
14902static void
14903print_mips_fp_abi_value (unsigned int val)
14904{
14905 switch (val)
14906 {
14907 case Val_GNU_MIPS_ABI_FP_ANY:
14908 printf (_("Hard or soft float\n"));
14909 break;
14910 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14911 printf (_("Hard float (double precision)\n"));
14912 break;
14913 case Val_GNU_MIPS_ABI_FP_SINGLE:
14914 printf (_("Hard float (single precision)\n"));
14915 break;
14916 case Val_GNU_MIPS_ABI_FP_SOFT:
14917 printf (_("Soft float\n"));
14918 break;
14919 case Val_GNU_MIPS_ABI_FP_OLD_64:
14920 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14921 break;
14922 case Val_GNU_MIPS_ABI_FP_XX:
14923 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14924 break;
14925 case Val_GNU_MIPS_ABI_FP_64:
14926 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14927 break;
14928 case Val_GNU_MIPS_ABI_FP_64A:
14929 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14930 break;
14931 case Val_GNU_MIPS_ABI_FP_NAN2008:
14932 printf (_("NaN 2008 compatibility\n"));
14933 break;
14934 default:
14935 printf ("??? (%d)\n", val);
14936 break;
14937 }
14938}
14939
14940static unsigned char *
14941display_mips_gnu_attribute (unsigned char * p,
14942 unsigned int tag,
14943 const unsigned char * const end)
14944{
14945 if (tag == Tag_GNU_MIPS_ABI_FP)
14946 {
14947 unsigned int len;
14948 unsigned int val;
14949
14950 val = read_uleb128 (p, &len, end);
14951 p += len;
14952 printf (" Tag_GNU_MIPS_ABI_FP: ");
14953
14954 print_mips_fp_abi_value (val);
14955
14956 return p;
14957 }
14958
14959 if (tag == Tag_GNU_MIPS_ABI_MSA)
14960 {
14961 unsigned int len;
14962 unsigned int val;
14963
14964 val = read_uleb128 (p, &len, end);
14965 p += len;
14966 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14967
14968 switch (val)
14969 {
14970 case Val_GNU_MIPS_ABI_MSA_ANY:
14971 printf (_("Any MSA or not\n"));
14972 break;
14973 case Val_GNU_MIPS_ABI_MSA_128:
14974 printf (_("128-bit MSA\n"));
14975 break;
14976 default:
14977 printf ("??? (%d)\n", val);
14978 break;
14979 }
14980 return p;
14981 }
14982
14983 return display_tag_value (tag & 1, p, end);
14984}
14985
14986static unsigned char *
14987display_tic6x_attribute (unsigned char * p,
14988 const unsigned char * const end)
14989{
14990 unsigned int tag;
14991 unsigned int len;
14992 int val;
14993
14994 tag = read_uleb128 (p, &len, end);
14995 p += len;
14996
14997 switch (tag)
14998 {
14999 case Tag_ISA:
15000 val = read_uleb128 (p, &len, end);
15001 p += len;
15002 printf (" Tag_ISA: ");
15003
15004 switch (val)
15005 {
15006 case C6XABI_Tag_ISA_none:
15007 printf (_("None\n"));
15008 break;
15009 case C6XABI_Tag_ISA_C62X:
15010 printf ("C62x\n");
15011 break;
15012 case C6XABI_Tag_ISA_C67X:
15013 printf ("C67x\n");
15014 break;
15015 case C6XABI_Tag_ISA_C67XP:
15016 printf ("C67x+\n");
15017 break;
15018 case C6XABI_Tag_ISA_C64X:
15019 printf ("C64x\n");
15020 break;
15021 case C6XABI_Tag_ISA_C64XP:
15022 printf ("C64x+\n");
15023 break;
15024 case C6XABI_Tag_ISA_C674X:
15025 printf ("C674x\n");
15026 break;
15027 default:
15028 printf ("??? (%d)\n", val);
15029 break;
15030 }
15031 return p;
15032
15033 case Tag_ABI_wchar_t:
15034 val = read_uleb128 (p, &len, end);
15035 p += len;
15036 printf (" Tag_ABI_wchar_t: ");
15037 switch (val)
15038 {
15039 case 0:
15040 printf (_("Not used\n"));
15041 break;
15042 case 1:
15043 printf (_("2 bytes\n"));
15044 break;
15045 case 2:
15046 printf (_("4 bytes\n"));
15047 break;
15048 default:
15049 printf ("??? (%d)\n", val);
15050 break;
15051 }
15052 return p;
15053
15054 case Tag_ABI_stack_align_needed:
15055 val = read_uleb128 (p, &len, end);
15056 p += len;
15057 printf (" Tag_ABI_stack_align_needed: ");
15058 switch (val)
15059 {
15060 case 0:
15061 printf (_("8-byte\n"));
15062 break;
15063 case 1:
15064 printf (_("16-byte\n"));
15065 break;
15066 default:
15067 printf ("??? (%d)\n", val);
15068 break;
15069 }
15070 return p;
15071
15072 case Tag_ABI_stack_align_preserved:
15073 val = read_uleb128 (p, &len, end);
15074 p += len;
15075 printf (" Tag_ABI_stack_align_preserved: ");
15076 switch (val)
15077 {
15078 case 0:
15079 printf (_("8-byte\n"));
15080 break;
15081 case 1:
15082 printf (_("16-byte\n"));
15083 break;
15084 default:
15085 printf ("??? (%d)\n", val);
15086 break;
15087 }
15088 return p;
15089
15090 case Tag_ABI_DSBT:
15091 val = read_uleb128 (p, &len, end);
15092 p += len;
15093 printf (" Tag_ABI_DSBT: ");
15094 switch (val)
15095 {
15096 case 0:
15097 printf (_("DSBT addressing not used\n"));
15098 break;
15099 case 1:
15100 printf (_("DSBT addressing used\n"));
15101 break;
15102 default:
15103 printf ("??? (%d)\n", val);
15104 break;
15105 }
15106 return p;
15107
15108 case Tag_ABI_PID:
15109 val = read_uleb128 (p, &len, end);
15110 p += len;
15111 printf (" Tag_ABI_PID: ");
15112 switch (val)
15113 {
15114 case 0:
15115 printf (_("Data addressing position-dependent\n"));
15116 break;
15117 case 1:
15118 printf (_("Data addressing position-independent, GOT near DP\n"));
15119 break;
15120 case 2:
15121 printf (_("Data addressing position-independent, GOT far from DP\n"));
15122 break;
15123 default:
15124 printf ("??? (%d)\n", val);
15125 break;
15126 }
15127 return p;
15128
15129 case Tag_ABI_PIC:
15130 val = read_uleb128 (p, &len, end);
15131 p += len;
15132 printf (" Tag_ABI_PIC: ");
15133 switch (val)
15134 {
15135 case 0:
15136 printf (_("Code addressing position-dependent\n"));
15137 break;
15138 case 1:
15139 printf (_("Code addressing position-independent\n"));
15140 break;
15141 default:
15142 printf ("??? (%d)\n", val);
15143 break;
15144 }
15145 return p;
15146
15147 case Tag_ABI_array_object_alignment:
15148 val = read_uleb128 (p, &len, end);
15149 p += len;
15150 printf (" Tag_ABI_array_object_alignment: ");
15151 switch (val)
15152 {
15153 case 0:
15154 printf (_("8-byte\n"));
15155 break;
15156 case 1:
15157 printf (_("4-byte\n"));
15158 break;
15159 case 2:
15160 printf (_("16-byte\n"));
15161 break;
15162 default:
15163 printf ("??? (%d)\n", val);
15164 break;
15165 }
15166 return p;
15167
15168 case Tag_ABI_array_object_align_expected:
15169 val = read_uleb128 (p, &len, end);
15170 p += len;
15171 printf (" Tag_ABI_array_object_align_expected: ");
15172 switch (val)
15173 {
15174 case 0:
15175 printf (_("8-byte\n"));
15176 break;
15177 case 1:
15178 printf (_("4-byte\n"));
15179 break;
15180 case 2:
15181 printf (_("16-byte\n"));
15182 break;
15183 default:
15184 printf ("??? (%d)\n", val);
15185 break;
15186 }
15187 return p;
15188
15189 case Tag_ABI_compatibility:
15190 {
15191 val = read_uleb128 (p, &len, end);
15192 p += len;
15193 printf (" Tag_ABI_compatibility: ");
15194 printf (_("flag = %d, vendor = "), val);
15195 if (p < end - 1)
15196 {
15197 size_t maxlen = (end - p) - 1;
15198
15199 print_symbol ((int) maxlen, (const char *) p);
15200 p += strnlen ((char *) p, maxlen) + 1;
15201 }
15202 else
15203 {
15204 printf (_("<corrupt>"));
15205 p = (unsigned char *) end;
15206 }
15207 putchar ('\n');
15208 return p;
15209 }
15210
15211 case Tag_ABI_conformance:
15212 {
15213 printf (" Tag_ABI_conformance: \"");
15214 if (p < end - 1)
15215 {
15216 size_t maxlen = (end - p) - 1;
15217
15218 print_symbol ((int) maxlen, (const char *) p);
15219 p += strnlen ((char *) p, maxlen) + 1;
15220 }
15221 else
15222 {
15223 printf (_("<corrupt>"));
15224 p = (unsigned char *) end;
15225 }
15226 printf ("\"\n");
15227 return p;
15228 }
15229 }
15230
15231 return display_tag_value (tag, p, end);
15232}
15233
15234static void
15235display_raw_attribute (unsigned char * p, unsigned char const * const end)
15236{
15237 unsigned long addr = 0;
15238 size_t bytes = end - p;
15239
15240 assert (end >= p);
15241 while (bytes)
15242 {
15243 int j;
15244 int k;
15245 int lbytes = (bytes > 16 ? 16 : bytes);
15246
15247 printf (" 0x%8.8lx ", addr);
15248
15249 for (j = 0; j < 16; j++)
15250 {
15251 if (j < lbytes)
15252 printf ("%2.2x", p[j]);
15253 else
15254 printf (" ");
15255
15256 if ((j & 3) == 3)
15257 printf (" ");
15258 }
15259
15260 for (j = 0; j < lbytes; j++)
15261 {
15262 k = p[j];
15263 if (k >= ' ' && k < 0x7f)
15264 printf ("%c", k);
15265 else
15266 printf (".");
15267 }
15268
15269 putchar ('\n');
15270
15271 p += lbytes;
15272 bytes -= lbytes;
15273 addr += lbytes;
15274 }
15275
15276 putchar ('\n');
15277}
15278
15279static unsigned char *
15280display_msp430x_attribute (unsigned char * p,
15281 const unsigned char * const end)
15282{
15283 unsigned int len;
15284 unsigned int val;
15285 unsigned int tag;
15286
15287 tag = read_uleb128 (p, & len, end);
15288 p += len;
15289
15290 switch (tag)
15291 {
15292 case OFBA_MSPABI_Tag_ISA:
15293 val = read_uleb128 (p, &len, end);
15294 p += len;
15295 printf (" Tag_ISA: ");
15296 switch (val)
15297 {
15298 case 0: printf (_("None\n")); break;
15299 case 1: printf (_("MSP430\n")); break;
15300 case 2: printf (_("MSP430X\n")); break;
15301 default: printf ("??? (%d)\n", val); break;
15302 }
15303 break;
15304
15305 case OFBA_MSPABI_Tag_Code_Model:
15306 val = read_uleb128 (p, &len, end);
15307 p += len;
15308 printf (" Tag_Code_Model: ");
15309 switch (val)
15310 {
15311 case 0: printf (_("None\n")); break;
15312 case 1: printf (_("Small\n")); break;
15313 case 2: printf (_("Large\n")); break;
15314 default: printf ("??? (%d)\n", val); break;
15315 }
15316 break;
15317
15318 case OFBA_MSPABI_Tag_Data_Model:
15319 val = read_uleb128 (p, &len, end);
15320 p += len;
15321 printf (" Tag_Data_Model: ");
15322 switch (val)
15323 {
15324 case 0: printf (_("None\n")); break;
15325 case 1: printf (_("Small\n")); break;
15326 case 2: printf (_("Large\n")); break;
15327 case 3: printf (_("Restricted Large\n")); break;
15328 default: printf ("??? (%d)\n", val); break;
15329 }
15330 break;
15331
15332 default:
15333 printf (_(" <unknown tag %d>: "), tag);
15334
15335 if (tag & 1)
15336 {
15337 putchar ('"');
15338 if (p < end - 1)
15339 {
15340 size_t maxlen = (end - p) - 1;
15341
15342 print_symbol ((int) maxlen, (const char *) p);
15343 p += strnlen ((char *) p, maxlen) + 1;
15344 }
15345 else
15346 {
15347 printf (_("<corrupt>"));
15348 p = (unsigned char *) end;
15349 }
15350 printf ("\"\n");
15351 }
15352 else
15353 {
15354 val = read_uleb128 (p, &len, end);
15355 p += len;
15356 printf ("%d (0x%x)\n", val, val);
15357 }
15358 break;
15359 }
15360
15361 assert (p <= end);
15362 return p;
15363}
15364
15365static bfd_boolean
15366process_attributes (Filedata * filedata,
15367 const char * public_name,
15368 unsigned int proc_type,
15369 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15370 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15371{
15372 Elf_Internal_Shdr * sect;
15373 unsigned i;
15374 bfd_boolean res = TRUE;
15375
15376 /* Find the section header so that we get the size. */
15377 for (i = 0, sect = filedata->section_headers;
15378 i < filedata->file_header.e_shnum;
15379 i++, sect++)
15380 {
15381 unsigned char * contents;
15382 unsigned char * p;
15383
15384 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15385 continue;
15386
15387 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15388 sect->sh_size, _("attributes"));
15389 if (contents == NULL)
15390 {
15391 res = FALSE;
15392 continue;
15393 }
15394
15395 p = contents;
15396 /* The first character is the version of the attributes.
15397 Currently only version 1, (aka 'A') is recognised here. */
15398 if (*p != 'A')
15399 {
15400 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15401 res = FALSE;
15402 }
15403 else
15404 {
15405 bfd_vma section_len;
15406
15407 section_len = sect->sh_size - 1;
15408 p++;
15409
15410 while (section_len > 0)
15411 {
15412 bfd_vma attr_len;
15413 unsigned int namelen;
15414 bfd_boolean public_section;
15415 bfd_boolean gnu_section;
15416
15417 if (section_len <= 4)
15418 {
15419 error (_("Tag section ends prematurely\n"));
15420 res = FALSE;
15421 break;
15422 }
15423 attr_len = byte_get (p, 4);
15424 p += 4;
15425
15426 if (attr_len > section_len)
15427 {
15428 error (_("Bad attribute length (%u > %u)\n"),
15429 (unsigned) attr_len, (unsigned) section_len);
15430 attr_len = section_len;
15431 res = FALSE;
15432 }
15433 /* PR 17531: file: 001-101425-0.004 */
15434 else if (attr_len < 5)
15435 {
15436 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15437 res = FALSE;
15438 break;
15439 }
15440
15441 section_len -= attr_len;
15442 attr_len -= 4;
15443
15444 namelen = strnlen ((char *) p, attr_len) + 1;
15445 if (namelen == 0 || namelen >= attr_len)
15446 {
15447 error (_("Corrupt attribute section name\n"));
15448 res = FALSE;
15449 break;
15450 }
15451
15452 printf (_("Attribute Section: "));
15453 print_symbol (INT_MAX, (const char *) p);
15454 putchar ('\n');
15455
15456 if (public_name && streq ((char *) p, public_name))
15457 public_section = TRUE;
15458 else
15459 public_section = FALSE;
15460
15461 if (streq ((char *) p, "gnu"))
15462 gnu_section = TRUE;
15463 else
15464 gnu_section = FALSE;
15465
15466 p += namelen;
15467 attr_len -= namelen;
15468
15469 while (attr_len > 0 && p < contents + sect->sh_size)
15470 {
15471 int tag;
15472 int val;
15473 bfd_vma size;
15474 unsigned char * end;
15475
15476 /* PR binutils/17531: Safe handling of corrupt files. */
15477 if (attr_len < 6)
15478 {
15479 error (_("Unused bytes at end of section\n"));
15480 res = FALSE;
15481 section_len = 0;
15482 break;
15483 }
15484
15485 tag = *(p++);
15486 size = byte_get (p, 4);
15487 if (size > attr_len)
15488 {
15489 error (_("Bad subsection length (%u > %u)\n"),
15490 (unsigned) size, (unsigned) attr_len);
15491 res = FALSE;
15492 size = attr_len;
15493 }
15494 /* PR binutils/17531: Safe handling of corrupt files. */
15495 if (size < 6)
15496 {
15497 error (_("Bad subsection length (%u < 6)\n"),
15498 (unsigned) size);
15499 res = FALSE;
15500 section_len = 0;
15501 break;
15502 }
15503
15504 attr_len -= size;
15505 end = p + size - 1;
15506 assert (end <= contents + sect->sh_size);
15507 p += 4;
15508
15509 switch (tag)
15510 {
15511 case 1:
15512 printf (_("File Attributes\n"));
15513 break;
15514 case 2:
15515 printf (_("Section Attributes:"));
15516 goto do_numlist;
15517 case 3:
15518 printf (_("Symbol Attributes:"));
15519 /* Fall through. */
15520 do_numlist:
15521 for (;;)
15522 {
15523 unsigned int j;
15524
15525 val = read_uleb128 (p, &j, end);
15526 p += j;
15527 if (val == 0)
15528 break;
15529 printf (" %d", val);
15530 }
15531 printf ("\n");
15532 break;
15533 default:
15534 printf (_("Unknown tag: %d\n"), tag);
15535 public_section = FALSE;
15536 break;
15537 }
15538
15539 if (public_section && display_pub_attribute != NULL)
15540 {
15541 while (p < end)
15542 p = display_pub_attribute (p, end);
15543 assert (p == end);
15544 }
15545 else if (gnu_section && display_proc_gnu_attribute != NULL)
15546 {
15547 while (p < end)
15548 p = display_gnu_attribute (p,
15549 display_proc_gnu_attribute,
15550 end);
15551 assert (p == end);
15552 }
15553 else if (p < end)
15554 {
15555 printf (_(" Unknown attribute:\n"));
15556 display_raw_attribute (p, end);
15557 p = end;
15558 }
15559 else
15560 attr_len = 0;
15561 }
15562 }
15563 }
15564
15565 free (contents);
15566 }
15567
15568 return res;
15569}
15570
15571/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15572 Print the Address, Access and Initial fields of an entry at VMA ADDR
15573 and return the VMA of the next entry, or -1 if there was a problem.
15574 Does not read from DATA_END or beyond. */
15575
15576static bfd_vma
15577print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15578 unsigned char * data_end)
15579{
15580 printf (" ");
15581 print_vma (addr, LONG_HEX);
15582 printf (" ");
15583 if (addr < pltgot + 0xfff0)
15584 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15585 else
15586 printf ("%10s", "");
15587 printf (" ");
15588 if (data == NULL)
15589 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15590 else
15591 {
15592 bfd_vma entry;
15593 unsigned char * from = data + addr - pltgot;
15594
15595 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15596 {
15597 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15598 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15599 return (bfd_vma) -1;
15600 }
15601 else
15602 {
15603 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15604 print_vma (entry, LONG_HEX);
15605 }
15606 }
15607 return addr + (is_32bit_elf ? 4 : 8);
15608}
15609
15610/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15611 PLTGOT. Print the Address and Initial fields of an entry at VMA
15612 ADDR and return the VMA of the next entry. */
15613
15614static bfd_vma
15615print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15616{
15617 printf (" ");
15618 print_vma (addr, LONG_HEX);
15619 printf (" ");
15620 if (data == NULL)
15621 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15622 else
15623 {
15624 bfd_vma entry;
15625
15626 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15627 print_vma (entry, LONG_HEX);
15628 }
15629 return addr + (is_32bit_elf ? 4 : 8);
15630}
15631
15632static void
15633print_mips_ases (unsigned int mask)
15634{
15635 if (mask & AFL_ASE_DSP)
15636 fputs ("\n\tDSP ASE", stdout);
15637 if (mask & AFL_ASE_DSPR2)
15638 fputs ("\n\tDSP R2 ASE", stdout);
15639 if (mask & AFL_ASE_DSPR3)
15640 fputs ("\n\tDSP R3 ASE", stdout);
15641 if (mask & AFL_ASE_EVA)
15642 fputs ("\n\tEnhanced VA Scheme", stdout);
15643 if (mask & AFL_ASE_MCU)
15644 fputs ("\n\tMCU (MicroController) ASE", stdout);
15645 if (mask & AFL_ASE_MDMX)
15646 fputs ("\n\tMDMX ASE", stdout);
15647 if (mask & AFL_ASE_MIPS3D)
15648 fputs ("\n\tMIPS-3D ASE", stdout);
15649 if (mask & AFL_ASE_MT)
15650 fputs ("\n\tMT ASE", stdout);
15651 if (mask & AFL_ASE_SMARTMIPS)
15652 fputs ("\n\tSmartMIPS ASE", stdout);
15653 if (mask & AFL_ASE_VIRT)
15654 fputs ("\n\tVZ ASE", stdout);
15655 if (mask & AFL_ASE_MSA)
15656 fputs ("\n\tMSA ASE", stdout);
15657 if (mask & AFL_ASE_MIPS16)
15658 fputs ("\n\tMIPS16 ASE", stdout);
15659 if (mask & AFL_ASE_MICROMIPS)
15660 fputs ("\n\tMICROMIPS ASE", stdout);
15661 if (mask & AFL_ASE_XPA)
15662 fputs ("\n\tXPA ASE", stdout);
15663 if (mask & AFL_ASE_MIPS16E2)
15664 fputs ("\n\tMIPS16e2 ASE", stdout);
15665 if (mask & AFL_ASE_CRC)
15666 fputs ("\n\tCRC ASE", stdout);
15667 if (mask & AFL_ASE_GINV)
15668 fputs ("\n\tGINV ASE", stdout);
15669 if (mask & AFL_ASE_LOONGSON_MMI)
15670 fputs ("\n\tLoongson MMI ASE", stdout);
15671 if (mask & AFL_ASE_LOONGSON_CAM)
15672 fputs ("\n\tLoongson CAM ASE", stdout);
15673 if (mask & AFL_ASE_LOONGSON_EXT)
15674 fputs ("\n\tLoongson EXT ASE", stdout);
15675 if (mask & AFL_ASE_LOONGSON_EXT2)
15676 fputs ("\n\tLoongson EXT2 ASE", stdout);
15677 if (mask == 0)
15678 fprintf (stdout, "\n\t%s", _("None"));
15679 else if ((mask & ~AFL_ASE_MASK) != 0)
15680 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15681}
15682
15683static void
15684print_mips_isa_ext (unsigned int isa_ext)
15685{
15686 switch (isa_ext)
15687 {
15688 case 0:
15689 fputs (_("None"), stdout);
15690 break;
15691 case AFL_EXT_XLR:
15692 fputs ("RMI XLR", stdout);
15693 break;
15694 case AFL_EXT_OCTEON3:
15695 fputs ("Cavium Networks Octeon3", stdout);
15696 break;
15697 case AFL_EXT_OCTEON2:
15698 fputs ("Cavium Networks Octeon2", stdout);
15699 break;
15700 case AFL_EXT_OCTEONP:
15701 fputs ("Cavium Networks OcteonP", stdout);
15702 break;
15703 case AFL_EXT_OCTEON:
15704 fputs ("Cavium Networks Octeon", stdout);
15705 break;
15706 case AFL_EXT_5900:
15707 fputs ("Toshiba R5900", stdout);
15708 break;
15709 case AFL_EXT_4650:
15710 fputs ("MIPS R4650", stdout);
15711 break;
15712 case AFL_EXT_4010:
15713 fputs ("LSI R4010", stdout);
15714 break;
15715 case AFL_EXT_4100:
15716 fputs ("NEC VR4100", stdout);
15717 break;
15718 case AFL_EXT_3900:
15719 fputs ("Toshiba R3900", stdout);
15720 break;
15721 case AFL_EXT_10000:
15722 fputs ("MIPS R10000", stdout);
15723 break;
15724 case AFL_EXT_SB1:
15725 fputs ("Broadcom SB-1", stdout);
15726 break;
15727 case AFL_EXT_4111:
15728 fputs ("NEC VR4111/VR4181", stdout);
15729 break;
15730 case AFL_EXT_4120:
15731 fputs ("NEC VR4120", stdout);
15732 break;
15733 case AFL_EXT_5400:
15734 fputs ("NEC VR5400", stdout);
15735 break;
15736 case AFL_EXT_5500:
15737 fputs ("NEC VR5500", stdout);
15738 break;
15739 case AFL_EXT_LOONGSON_2E:
15740 fputs ("ST Microelectronics Loongson 2E", stdout);
15741 break;
15742 case AFL_EXT_LOONGSON_2F:
15743 fputs ("ST Microelectronics Loongson 2F", stdout);
15744 break;
15745 case AFL_EXT_INTERAPTIV_MR2:
15746 fputs ("Imagination interAptiv MR2", stdout);
15747 break;
15748 default:
15749 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15750 }
15751}
15752
15753static signed int
15754get_mips_reg_size (int reg_size)
15755{
15756 return (reg_size == AFL_REG_NONE) ? 0
15757 : (reg_size == AFL_REG_32) ? 32
15758 : (reg_size == AFL_REG_64) ? 64
15759 : (reg_size == AFL_REG_128) ? 128
15760 : -1;
15761}
15762
15763static bfd_boolean
15764process_mips_specific (Filedata * filedata)
15765{
15766 Elf_Internal_Dyn * entry;
15767 Elf_Internal_Shdr *sect = NULL;
15768 size_t liblist_offset = 0;
15769 size_t liblistno = 0;
15770 size_t conflictsno = 0;
15771 size_t options_offset = 0;
15772 size_t conflicts_offset = 0;
15773 size_t pltrelsz = 0;
15774 size_t pltrel = 0;
15775 bfd_vma pltgot = 0;
15776 bfd_vma mips_pltgot = 0;
15777 bfd_vma jmprel = 0;
15778 bfd_vma local_gotno = 0;
15779 bfd_vma gotsym = 0;
15780 bfd_vma symtabno = 0;
15781 bfd_boolean res = TRUE;
15782
15783 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15784 display_mips_gnu_attribute))
15785 res = FALSE;
15786
15787 sect = find_section (filedata, ".MIPS.abiflags");
15788
15789 if (sect != NULL)
15790 {
15791 Elf_External_ABIFlags_v0 *abiflags_ext;
15792 Elf_Internal_ABIFlags_v0 abiflags_in;
15793
15794 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15795 {
15796 error (_("Corrupt MIPS ABI Flags section.\n"));
15797 res = FALSE;
15798 }
15799 else
15800 {
15801 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15802 sect->sh_size, _("MIPS ABI Flags section"));
15803 if (abiflags_ext)
15804 {
15805 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15806 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15807 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15808 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15809 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15810 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15811 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15812 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15813 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15814 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15815 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15816
15817 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15818 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15819 if (abiflags_in.isa_rev > 1)
15820 printf ("r%d", abiflags_in.isa_rev);
15821 printf ("\nGPR size: %d",
15822 get_mips_reg_size (abiflags_in.gpr_size));
15823 printf ("\nCPR1 size: %d",
15824 get_mips_reg_size (abiflags_in.cpr1_size));
15825 printf ("\nCPR2 size: %d",
15826 get_mips_reg_size (abiflags_in.cpr2_size));
15827 fputs ("\nFP ABI: ", stdout);
15828 print_mips_fp_abi_value (abiflags_in.fp_abi);
15829 fputs ("ISA Extension: ", stdout);
15830 print_mips_isa_ext (abiflags_in.isa_ext);
15831 fputs ("\nASEs:", stdout);
15832 print_mips_ases (abiflags_in.ases);
15833 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15834 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15835 fputc ('\n', stdout);
15836 free (abiflags_ext);
15837 }
15838 }
15839 }
15840
15841 /* We have a lot of special sections. Thanks SGI! */
15842 if (dynamic_section == NULL)
15843 {
15844 /* No dynamic information available. See if there is static GOT. */
15845 sect = find_section (filedata, ".got");
15846 if (sect != NULL)
15847 {
15848 unsigned char *data_end;
15849 unsigned char *data;
15850 bfd_vma ent, end;
15851 int addr_size;
15852
15853 pltgot = sect->sh_addr;
15854
15855 ent = pltgot;
15856 addr_size = (is_32bit_elf ? 4 : 8);
15857 end = pltgot + sect->sh_size;
15858
15859 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15860 end - pltgot, 1,
15861 _("Global Offset Table data"));
15862 /* PR 12855: Null data is handled gracefully throughout. */
15863 data_end = data + (end - pltgot);
15864
15865 printf (_("\nStatic GOT:\n"));
15866 printf (_(" Canonical gp value: "));
15867 print_vma (ent + 0x7ff0, LONG_HEX);
15868 printf ("\n\n");
15869
15870 /* In a dynamic binary GOT[0] is reserved for the dynamic
15871 loader to store the lazy resolver pointer, however in
15872 a static binary it may well have been omitted and GOT
15873 reduced to a table of addresses.
15874 PR 21344: Check for the entry being fully available
15875 before fetching it. */
15876 if (data
15877 && data + ent - pltgot + addr_size <= data_end
15878 && byte_get (data + ent - pltgot, addr_size) == 0)
15879 {
15880 printf (_(" Reserved entries:\n"));
15881 printf (_(" %*s %10s %*s\n"),
15882 addr_size * 2, _("Address"), _("Access"),
15883 addr_size * 2, _("Value"));
15884 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15885 printf ("\n");
15886 if (ent == (bfd_vma) -1)
15887 goto sgot_print_fail;
15888
15889 /* Check for the MSB of GOT[1] being set, identifying a
15890 GNU object. This entry will be used by some runtime
15891 loaders, to store the module pointer. Otherwise this
15892 is an ordinary local entry.
15893 PR 21344: Check for the entry being fully available
15894 before fetching it. */
15895 if (data
15896 && data + ent - pltgot + addr_size <= data_end
15897 && (byte_get (data + ent - pltgot, addr_size)
15898 >> (addr_size * 8 - 1)) != 0)
15899 {
15900 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15901 printf ("\n");
15902 if (ent == (bfd_vma) -1)
15903 goto sgot_print_fail;
15904 }
15905 printf ("\n");
15906 }
15907
15908 if (data != NULL && ent < end)
15909 {
15910 printf (_(" Local entries:\n"));
15911 printf (" %*s %10s %*s\n",
15912 addr_size * 2, _("Address"), _("Access"),
15913 addr_size * 2, _("Value"));
15914 while (ent < end)
15915 {
15916 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15917 printf ("\n");
15918 if (ent == (bfd_vma) -1)
15919 goto sgot_print_fail;
15920 }
15921 printf ("\n");
15922 }
15923
15924 sgot_print_fail:
15925 if (data)
15926 free (data);
15927 }
15928 return res;
15929 }
15930
15931 for (entry = dynamic_section;
15932 /* PR 17531 file: 012-50589-0.004. */
15933 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15934 ++entry)
15935 switch (entry->d_tag)
15936 {
15937 case DT_MIPS_LIBLIST:
15938 liblist_offset
15939 = offset_from_vma (filedata, entry->d_un.d_val,
15940 liblistno * sizeof (Elf32_External_Lib));
15941 break;
15942 case DT_MIPS_LIBLISTNO:
15943 liblistno = entry->d_un.d_val;
15944 break;
15945 case DT_MIPS_OPTIONS:
15946 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15947 break;
15948 case DT_MIPS_CONFLICT:
15949 conflicts_offset
15950 = offset_from_vma (filedata, entry->d_un.d_val,
15951 conflictsno * sizeof (Elf32_External_Conflict));
15952 break;
15953 case DT_MIPS_CONFLICTNO:
15954 conflictsno = entry->d_un.d_val;
15955 break;
15956 case DT_PLTGOT:
15957 pltgot = entry->d_un.d_ptr;
15958 break;
15959 case DT_MIPS_LOCAL_GOTNO:
15960 local_gotno = entry->d_un.d_val;
15961 break;
15962 case DT_MIPS_GOTSYM:
15963 gotsym = entry->d_un.d_val;
15964 break;
15965 case DT_MIPS_SYMTABNO:
15966 symtabno = entry->d_un.d_val;
15967 break;
15968 case DT_MIPS_PLTGOT:
15969 mips_pltgot = entry->d_un.d_ptr;
15970 break;
15971 case DT_PLTREL:
15972 pltrel = entry->d_un.d_val;
15973 break;
15974 case DT_PLTRELSZ:
15975 pltrelsz = entry->d_un.d_val;
15976 break;
15977 case DT_JMPREL:
15978 jmprel = entry->d_un.d_ptr;
15979 break;
15980 default:
15981 break;
15982 }
15983
15984 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15985 {
15986 Elf32_External_Lib * elib;
15987 size_t cnt;
15988
15989 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15990 liblistno,
15991 sizeof (Elf32_External_Lib),
15992 _("liblist section data"));
15993 if (elib)
15994 {
15995 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15996 "\nSection '.liblist' contains %lu entries:\n",
15997 (unsigned long) liblistno),
15998 (unsigned long) liblistno);
15999 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16000 stdout);
16001
16002 for (cnt = 0; cnt < liblistno; ++cnt)
16003 {
16004 Elf32_Lib liblist;
16005 time_t atime;
16006 char timebuf[128];
16007 struct tm * tmp;
16008
16009 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16010 atime = BYTE_GET (elib[cnt].l_time_stamp);
16011 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16012 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16013 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16014
16015 tmp = gmtime (&atime);
16016 snprintf (timebuf, sizeof (timebuf),
16017 "%04u-%02u-%02uT%02u:%02u:%02u",
16018 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16019 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16020
16021 printf ("%3lu: ", (unsigned long) cnt);
16022 if (VALID_DYNAMIC_NAME (liblist.l_name))
16023 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16024 else
16025 printf (_("<corrupt: %9ld>"), liblist.l_name);
16026 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16027 liblist.l_version);
16028
16029 if (liblist.l_flags == 0)
16030 puts (_(" NONE"));
16031 else
16032 {
16033 static const struct
16034 {
16035 const char * name;
16036 int bit;
16037 }
16038 l_flags_vals[] =
16039 {
16040 { " EXACT_MATCH", LL_EXACT_MATCH },
16041 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16042 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16043 { " EXPORTS", LL_EXPORTS },
16044 { " DELAY_LOAD", LL_DELAY_LOAD },
16045 { " DELTA", LL_DELTA }
16046 };
16047 int flags = liblist.l_flags;
16048 size_t fcnt;
16049
16050 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16051 if ((flags & l_flags_vals[fcnt].bit) != 0)
16052 {
16053 fputs (l_flags_vals[fcnt].name, stdout);
16054 flags ^= l_flags_vals[fcnt].bit;
16055 }
16056 if (flags != 0)
16057 printf (" %#x", (unsigned int) flags);
16058
16059 puts ("");
16060 }
16061 }
16062
16063 free (elib);
16064 }
16065 else
16066 res = FALSE;
16067 }
16068
16069 if (options_offset != 0)
16070 {
16071 Elf_External_Options * eopt;
16072 Elf_Internal_Options * iopt;
16073 Elf_Internal_Options * option;
16074 size_t offset;
16075 int cnt;
16076 sect = filedata->section_headers;
16077
16078 /* Find the section header so that we get the size. */
16079 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16080 /* PR 17533 file: 012-277276-0.004. */
16081 if (sect == NULL)
16082 {
16083 error (_("No MIPS_OPTIONS header found\n"));
16084 return FALSE;
16085 }
16086
16087 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16088 sect->sh_size, _("options"));
16089 if (eopt)
16090 {
16091 iopt = (Elf_Internal_Options *)
16092 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16093 if (iopt == NULL)
16094 {
16095 error (_("Out of memory allocating space for MIPS options\n"));
16096 return FALSE;
16097 }
16098
16099 offset = cnt = 0;
16100 option = iopt;
16101
16102 while (offset <= sect->sh_size - sizeof (* eopt))
16103 {
16104 Elf_External_Options * eoption;
16105
16106 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16107
16108 option->kind = BYTE_GET (eoption->kind);
16109 option->size = BYTE_GET (eoption->size);
16110 option->section = BYTE_GET (eoption->section);
16111 option->info = BYTE_GET (eoption->info);
16112
16113 /* PR 17531: file: ffa0fa3b. */
16114 if (option->size < sizeof (* eopt)
16115 || offset + option->size > sect->sh_size)
16116 {
16117 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16118 return FALSE;
16119 }
16120 offset += option->size;
16121
16122 ++option;
16123 ++cnt;
16124 }
16125
16126 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16127 "\nSection '%s' contains %d entries:\n",
16128 cnt),
16129 printable_section_name (filedata, sect), cnt);
16130
16131 option = iopt;
16132 offset = 0;
16133
16134 while (cnt-- > 0)
16135 {
16136 size_t len;
16137
16138 switch (option->kind)
16139 {
16140 case ODK_NULL:
16141 /* This shouldn't happen. */
16142 printf (" NULL %d %lx", option->section, option->info);
16143 break;
16144 case ODK_REGINFO:
16145 printf (" REGINFO ");
16146 if (filedata->file_header.e_machine == EM_MIPS)
16147 {
16148 /* 32bit form. */
16149 Elf32_External_RegInfo * ereg;
16150 Elf32_RegInfo reginfo;
16151
16152 ereg = (Elf32_External_RegInfo *) (option + 1);
16153 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16154 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16155 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16156 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16157 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16158 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16159
16160 printf ("GPR %08lx GP 0x%lx\n",
16161 reginfo.ri_gprmask,
16162 (unsigned long) reginfo.ri_gp_value);
16163 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16164 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16165 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16166 }
16167 else
16168 {
16169 /* 64 bit form. */
16170 Elf64_External_RegInfo * ereg;
16171 Elf64_Internal_RegInfo reginfo;
16172
16173 ereg = (Elf64_External_RegInfo *) (option + 1);
16174 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16175 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16176 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16177 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16178 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16179 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16180
16181 printf ("GPR %08lx GP 0x",
16182 reginfo.ri_gprmask);
16183 printf_vma (reginfo.ri_gp_value);
16184 printf ("\n");
16185
16186 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16187 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16188 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16189 }
16190 ++option;
16191 continue;
16192 case ODK_EXCEPTIONS:
16193 fputs (" EXCEPTIONS fpe_min(", stdout);
16194 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16195 fputs (") fpe_max(", stdout);
16196 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16197 fputs (")", stdout);
16198
16199 if (option->info & OEX_PAGE0)
16200 fputs (" PAGE0", stdout);
16201 if (option->info & OEX_SMM)
16202 fputs (" SMM", stdout);
16203 if (option->info & OEX_FPDBUG)
16204 fputs (" FPDBUG", stdout);
16205 if (option->info & OEX_DISMISS)
16206 fputs (" DISMISS", stdout);
16207 break;
16208 case ODK_PAD:
16209 fputs (" PAD ", stdout);
16210 if (option->info & OPAD_PREFIX)
16211 fputs (" PREFIX", stdout);
16212 if (option->info & OPAD_POSTFIX)
16213 fputs (" POSTFIX", stdout);
16214 if (option->info & OPAD_SYMBOL)
16215 fputs (" SYMBOL", stdout);
16216 break;
16217 case ODK_HWPATCH:
16218 fputs (" HWPATCH ", stdout);
16219 if (option->info & OHW_R4KEOP)
16220 fputs (" R4KEOP", stdout);
16221 if (option->info & OHW_R8KPFETCH)
16222 fputs (" R8KPFETCH", stdout);
16223 if (option->info & OHW_R5KEOP)
16224 fputs (" R5KEOP", stdout);
16225 if (option->info & OHW_R5KCVTL)
16226 fputs (" R5KCVTL", stdout);
16227 break;
16228 case ODK_FILL:
16229 fputs (" FILL ", stdout);
16230 /* XXX Print content of info word? */
16231 break;
16232 case ODK_TAGS:
16233 fputs (" TAGS ", stdout);
16234 /* XXX Print content of info word? */
16235 break;
16236 case ODK_HWAND:
16237 fputs (" HWAND ", stdout);
16238 if (option->info & OHWA0_R4KEOP_CHECKED)
16239 fputs (" R4KEOP_CHECKED", stdout);
16240 if (option->info & OHWA0_R4KEOP_CLEAN)
16241 fputs (" R4KEOP_CLEAN", stdout);
16242 break;
16243 case ODK_HWOR:
16244 fputs (" HWOR ", stdout);
16245 if (option->info & OHWA0_R4KEOP_CHECKED)
16246 fputs (" R4KEOP_CHECKED", stdout);
16247 if (option->info & OHWA0_R4KEOP_CLEAN)
16248 fputs (" R4KEOP_CLEAN", stdout);
16249 break;
16250 case ODK_GP_GROUP:
16251 printf (" GP_GROUP %#06lx self-contained %#06lx",
16252 option->info & OGP_GROUP,
16253 (option->info & OGP_SELF) >> 16);
16254 break;
16255 case ODK_IDENT:
16256 printf (" IDENT %#06lx self-contained %#06lx",
16257 option->info & OGP_GROUP,
16258 (option->info & OGP_SELF) >> 16);
16259 break;
16260 default:
16261 /* This shouldn't happen. */
16262 printf (" %3d ??? %d %lx",
16263 option->kind, option->section, option->info);
16264 break;
16265 }
16266
16267 len = sizeof (* eopt);
16268 while (len < option->size)
16269 {
16270 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16271
16272 if (ISPRINT (datum))
16273 printf ("%c", datum);
16274 else
16275 printf ("\\%03o", datum);
16276 len ++;
16277 }
16278 fputs ("\n", stdout);
16279
16280 offset += option->size;
16281 ++option;
16282 }
16283
16284 free (eopt);
16285 }
16286 else
16287 res = FALSE;
16288 }
16289
16290 if (conflicts_offset != 0 && conflictsno != 0)
16291 {
16292 Elf32_Conflict * iconf;
16293 size_t cnt;
16294
16295 if (dynamic_symbols == NULL)
16296 {
16297 error (_("conflict list found without a dynamic symbol table\n"));
16298 return FALSE;
16299 }
16300
16301 /* PR 21345 - print a slightly more helpful error message
16302 if we are sure that the cmalloc will fail. */
16303 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16304 {
16305 error (_("Overlarge number of conflicts detected: %lx\n"),
16306 (long) conflictsno);
16307 return FALSE;
16308 }
16309
16310 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16311 if (iconf == NULL)
16312 {
16313 error (_("Out of memory allocating space for dynamic conflicts\n"));
16314 return FALSE;
16315 }
16316
16317 if (is_32bit_elf)
16318 {
16319 Elf32_External_Conflict * econf32;
16320
16321 econf32 = (Elf32_External_Conflict *)
16322 get_data (NULL, filedata, conflicts_offset, conflictsno,
16323 sizeof (* econf32), _("conflict"));
16324 if (!econf32)
16325 return FALSE;
16326
16327 for (cnt = 0; cnt < conflictsno; ++cnt)
16328 iconf[cnt] = BYTE_GET (econf32[cnt]);
16329
16330 free (econf32);
16331 }
16332 else
16333 {
16334 Elf64_External_Conflict * econf64;
16335
16336 econf64 = (Elf64_External_Conflict *)
16337 get_data (NULL, filedata, conflicts_offset, conflictsno,
16338 sizeof (* econf64), _("conflict"));
16339 if (!econf64)
16340 return FALSE;
16341
16342 for (cnt = 0; cnt < conflictsno; ++cnt)
16343 iconf[cnt] = BYTE_GET (econf64[cnt]);
16344
16345 free (econf64);
16346 }
16347
16348 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16349 "\nSection '.conflict' contains %lu entries:\n",
16350 (unsigned long) conflictsno),
16351 (unsigned long) conflictsno);
16352 puts (_(" Num: Index Value Name"));
16353
16354 for (cnt = 0; cnt < conflictsno; ++cnt)
16355 {
16356 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16357
16358 if (iconf[cnt] >= num_dynamic_syms)
16359 printf (_("<corrupt symbol index>"));
16360 else
16361 {
16362 Elf_Internal_Sym * psym;
16363
16364 psym = & dynamic_symbols[iconf[cnt]];
16365 print_vma (psym->st_value, FULL_HEX);
16366 putchar (' ');
16367 if (VALID_DYNAMIC_NAME (psym->st_name))
16368 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16369 else
16370 printf (_("<corrupt: %14ld>"), psym->st_name);
16371 }
16372 putchar ('\n');
16373 }
16374
16375 free (iconf);
16376 }
16377
16378 if (pltgot != 0 && local_gotno != 0)
16379 {
16380 bfd_vma ent, local_end, global_end;
16381 size_t i, offset;
16382 unsigned char * data;
16383 unsigned char * data_end;
16384 int addr_size;
16385
16386 ent = pltgot;
16387 addr_size = (is_32bit_elf ? 4 : 8);
16388 local_end = pltgot + local_gotno * addr_size;
16389
16390 /* PR binutils/17533 file: 012-111227-0.004 */
16391 if (symtabno < gotsym)
16392 {
16393 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16394 (unsigned long) gotsym, (unsigned long) symtabno);
16395 return FALSE;
16396 }
16397
16398 global_end = local_end + (symtabno - gotsym) * addr_size;
16399 /* PR 17531: file: 54c91a34. */
16400 if (global_end < local_end)
16401 {
16402 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16403 return FALSE;
16404 }
16405
16406 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16407 data = (unsigned char *) get_data (NULL, filedata, offset,
16408 global_end - pltgot, 1,
16409 _("Global Offset Table data"));
16410 /* PR 12855: Null data is handled gracefully throughout. */
16411 data_end = data + (global_end - pltgot);
16412
16413 printf (_("\nPrimary GOT:\n"));
16414 printf (_(" Canonical gp value: "));
16415 print_vma (pltgot + 0x7ff0, LONG_HEX);
16416 printf ("\n\n");
16417
16418 printf (_(" Reserved entries:\n"));
16419 printf (_(" %*s %10s %*s Purpose\n"),
16420 addr_size * 2, _("Address"), _("Access"),
16421 addr_size * 2, _("Initial"));
16422 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16423 printf (_(" Lazy resolver\n"));
16424 if (ent == (bfd_vma) -1)
16425 goto got_print_fail;
16426
16427 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16428 This entry will be used by some runtime loaders, to store the
16429 module pointer. Otherwise this is an ordinary local entry.
16430 PR 21344: Check for the entry being fully available before
16431 fetching it. */
16432 if (data
16433 && data + ent - pltgot + addr_size <= data_end
16434 && (byte_get (data + ent - pltgot, addr_size)
16435 >> (addr_size * 8 - 1)) != 0)
16436 {
16437 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16438 printf (_(" Module pointer (GNU extension)\n"));
16439 if (ent == (bfd_vma) -1)
16440 goto got_print_fail;
16441 }
16442 printf ("\n");
16443
16444 if (data != NULL && ent < local_end)
16445 {
16446 printf (_(" Local entries:\n"));
16447 printf (" %*s %10s %*s\n",
16448 addr_size * 2, _("Address"), _("Access"),
16449 addr_size * 2, _("Initial"));
16450 while (ent < local_end)
16451 {
16452 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16453 printf ("\n");
16454 if (ent == (bfd_vma) -1)
16455 goto got_print_fail;
16456 }
16457 printf ("\n");
16458 }
16459
16460 if (data != NULL && gotsym < symtabno)
16461 {
16462 int sym_width;
16463
16464 printf (_(" Global entries:\n"));
16465 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16466 addr_size * 2, _("Address"),
16467 _("Access"),
16468 addr_size * 2, _("Initial"),
16469 addr_size * 2, _("Sym.Val."),
16470 _("Type"),
16471 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16472 _("Ndx"), _("Name"));
16473
16474 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16475
16476 for (i = gotsym; i < symtabno; i++)
16477 {
16478 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16479 printf (" ");
16480
16481 if (dynamic_symbols == NULL)
16482 printf (_("<no dynamic symbols>"));
16483 else if (i < num_dynamic_syms)
16484 {
16485 Elf_Internal_Sym * psym = dynamic_symbols + i;
16486
16487 print_vma (psym->st_value, LONG_HEX);
16488 printf (" %-7s %3s ",
16489 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16490 get_symbol_index_type (filedata, psym->st_shndx));
16491
16492 if (VALID_DYNAMIC_NAME (psym->st_name))
16493 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16494 else
16495 printf (_("<corrupt: %14ld>"), psym->st_name);
16496 }
16497 else
16498 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16499 (unsigned long) i);
16500
16501 printf ("\n");
16502 if (ent == (bfd_vma) -1)
16503 break;
16504 }
16505 printf ("\n");
16506 }
16507
16508 got_print_fail:
16509 if (data)
16510 free (data);
16511 }
16512
16513 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16514 {
16515 bfd_vma ent, end;
16516 size_t offset, rel_offset;
16517 unsigned long count, i;
16518 unsigned char * data;
16519 int addr_size, sym_width;
16520 Elf_Internal_Rela * rels;
16521
16522 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16523 if (pltrel == DT_RELA)
16524 {
16525 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16526 return FALSE;
16527 }
16528 else
16529 {
16530 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16531 return FALSE;
16532 }
16533
16534 ent = mips_pltgot;
16535 addr_size = (is_32bit_elf ? 4 : 8);
16536 end = mips_pltgot + (2 + count) * addr_size;
16537
16538 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16539 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16540 1, _("Procedure Linkage Table data"));
16541 if (data == NULL)
16542 return FALSE;
16543
16544 printf ("\nPLT GOT:\n\n");
16545 printf (_(" Reserved entries:\n"));
16546 printf (_(" %*s %*s Purpose\n"),
16547 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16548 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16549 printf (_(" PLT lazy resolver\n"));
16550 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16551 printf (_(" Module pointer\n"));
16552 printf ("\n");
16553
16554 printf (_(" Entries:\n"));
16555 printf (" %*s %*s %*s %-7s %3s %s\n",
16556 addr_size * 2, _("Address"),
16557 addr_size * 2, _("Initial"),
16558 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16559 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16560 for (i = 0; i < count; i++)
16561 {
16562 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16563
16564 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16565 printf (" ");
16566
16567 if (idx >= num_dynamic_syms)
16568 printf (_("<corrupt symbol index: %lu>"), idx);
16569 else
16570 {
16571 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16572
16573 print_vma (psym->st_value, LONG_HEX);
16574 printf (" %-7s %3s ",
16575 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16576 get_symbol_index_type (filedata, psym->st_shndx));
16577 if (VALID_DYNAMIC_NAME (psym->st_name))
16578 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16579 else
16580 printf (_("<corrupt: %14ld>"), psym->st_name);
16581 }
16582 printf ("\n");
16583 }
16584 printf ("\n");
16585
16586 if (data)
16587 free (data);
16588 free (rels);
16589 }
16590
16591 return res;
16592}
16593
16594static bfd_boolean
16595process_nds32_specific (Filedata * filedata)
16596{
16597 Elf_Internal_Shdr *sect = NULL;
16598
16599 sect = find_section (filedata, ".nds32_e_flags");
16600 if (sect != NULL)
16601 {
16602 unsigned int *flag;
16603
16604 printf ("\nNDS32 elf flags section:\n");
16605 flag = get_data (NULL, filedata, sect->sh_offset, 1,
16606 sect->sh_size, _("NDS32 elf flags section"));
16607
16608 if (! flag)
16609 return FALSE;
16610
16611 switch ((*flag) & 0x3)
16612 {
16613 case 0:
16614 printf ("(VEC_SIZE):\tNo entry.\n");
16615 break;
16616 case 1:
16617 printf ("(VEC_SIZE):\t4 bytes\n");
16618 break;
16619 case 2:
16620 printf ("(VEC_SIZE):\t16 bytes\n");
16621 break;
16622 case 3:
16623 printf ("(VEC_SIZE):\treserved\n");
16624 break;
16625 }
16626 }
16627
16628 return TRUE;
16629}
16630
16631static bfd_boolean
16632process_gnu_liblist (Filedata * filedata)
16633{
16634 Elf_Internal_Shdr * section;
16635 Elf_Internal_Shdr * string_sec;
16636 Elf32_External_Lib * elib;
16637 char * strtab;
16638 size_t strtab_size;
16639 size_t cnt;
16640 unsigned long num_liblist;
16641 unsigned i;
16642 bfd_boolean res = TRUE;
16643
16644 if (! do_arch)
16645 return TRUE;
16646
16647 for (i = 0, section = filedata->section_headers;
16648 i < filedata->file_header.e_shnum;
16649 i++, section++)
16650 {
16651 switch (section->sh_type)
16652 {
16653 case SHT_GNU_LIBLIST:
16654 if (section->sh_link >= filedata->file_header.e_shnum)
16655 break;
16656
16657 elib = (Elf32_External_Lib *)
16658 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16659 _("liblist section data"));
16660
16661 if (elib == NULL)
16662 {
16663 res = FALSE;
16664 break;
16665 }
16666
16667 string_sec = filedata->section_headers + section->sh_link;
16668 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16669 string_sec->sh_size,
16670 _("liblist string table"));
16671 if (strtab == NULL
16672 || section->sh_entsize != sizeof (Elf32_External_Lib))
16673 {
16674 free (elib);
16675 free (strtab);
16676 res = FALSE;
16677 break;
16678 }
16679 strtab_size = string_sec->sh_size;
16680
16681 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16682 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16683 "\nLibrary list section '%s' contains %lu entries:\n",
16684 num_liblist),
16685 printable_section_name (filedata, section),
16686 num_liblist);
16687
16688 puts (_(" Library Time Stamp Checksum Version Flags"));
16689
16690 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16691 ++cnt)
16692 {
16693 Elf32_Lib liblist;
16694 time_t atime;
16695 char timebuf[128];
16696 struct tm * tmp;
16697
16698 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16699 atime = BYTE_GET (elib[cnt].l_time_stamp);
16700 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16701 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16702 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16703
16704 tmp = gmtime (&atime);
16705 snprintf (timebuf, sizeof (timebuf),
16706 "%04u-%02u-%02uT%02u:%02u:%02u",
16707 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16708 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16709
16710 printf ("%3lu: ", (unsigned long) cnt);
16711 if (do_wide)
16712 printf ("%-20s", liblist.l_name < strtab_size
16713 ? strtab + liblist.l_name : _("<corrupt>"));
16714 else
16715 printf ("%-20.20s", liblist.l_name < strtab_size
16716 ? strtab + liblist.l_name : _("<corrupt>"));
16717 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16718 liblist.l_version, liblist.l_flags);
16719 }
16720
16721 free (elib);
16722 free (strtab);
16723 }
16724 }
16725
16726 return res;
16727}
16728
16729static const char *
16730get_note_type (Filedata * filedata, unsigned e_type)
16731{
16732 static char buff[64];
16733
16734 if (filedata->file_header.e_type == ET_CORE)
16735 switch (e_type)
16736 {
16737 case NT_AUXV:
16738 return _("NT_AUXV (auxiliary vector)");
16739 case NT_PRSTATUS:
16740 return _("NT_PRSTATUS (prstatus structure)");
16741 case NT_FPREGSET:
16742 return _("NT_FPREGSET (floating point registers)");
16743 case NT_PRPSINFO:
16744 return _("NT_PRPSINFO (prpsinfo structure)");
16745 case NT_TASKSTRUCT:
16746 return _("NT_TASKSTRUCT (task structure)");
16747 case NT_PRXFPREG:
16748 return _("NT_PRXFPREG (user_xfpregs structure)");
16749 case NT_PPC_VMX:
16750 return _("NT_PPC_VMX (ppc Altivec registers)");
16751 case NT_PPC_VSX:
16752 return _("NT_PPC_VSX (ppc VSX registers)");
16753 case NT_PPC_TAR:
16754 return _("NT_PPC_TAR (ppc TAR register)");
16755 case NT_PPC_PPR:
16756 return _("NT_PPC_PPR (ppc PPR register)");
16757 case NT_PPC_DSCR:
16758 return _("NT_PPC_DSCR (ppc DSCR register)");
16759 case NT_PPC_EBB:
16760 return _("NT_PPC_EBB (ppc EBB registers)");
16761 case NT_PPC_PMU:
16762 return _("NT_PPC_PMU (ppc PMU registers)");
16763 case NT_PPC_TM_CGPR:
16764 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16765 case NT_PPC_TM_CFPR:
16766 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16767 case NT_PPC_TM_CVMX:
16768 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16769 case NT_PPC_TM_CVSX:
16770 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16771 case NT_PPC_TM_SPR:
16772 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16773 case NT_PPC_TM_CTAR:
16774 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16775 case NT_PPC_TM_CPPR:
16776 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16777 case NT_PPC_TM_CDSCR:
16778 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16779 case NT_386_TLS:
16780 return _("NT_386_TLS (x86 TLS information)");
16781 case NT_386_IOPERM:
16782 return _("NT_386_IOPERM (x86 I/O permissions)");
16783 case NT_X86_XSTATE:
16784 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16785 case NT_S390_HIGH_GPRS:
16786 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16787 case NT_S390_TIMER:
16788 return _("NT_S390_TIMER (s390 timer register)");
16789 case NT_S390_TODCMP:
16790 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16791 case NT_S390_TODPREG:
16792 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16793 case NT_S390_CTRS:
16794 return _("NT_S390_CTRS (s390 control registers)");
16795 case NT_S390_PREFIX:
16796 return _("NT_S390_PREFIX (s390 prefix register)");
16797 case NT_S390_LAST_BREAK:
16798 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16799 case NT_S390_SYSTEM_CALL:
16800 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16801 case NT_S390_TDB:
16802 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16803 case NT_S390_VXRS_LOW:
16804 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16805 case NT_S390_VXRS_HIGH:
16806 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16807 case NT_S390_GS_CB:
16808 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16809 case NT_S390_GS_BC:
16810 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16811 case NT_ARM_VFP:
16812 return _("NT_ARM_VFP (arm VFP registers)");
16813 case NT_ARM_TLS:
16814 return _("NT_ARM_TLS (AArch TLS registers)");
16815 case NT_ARM_HW_BREAK:
16816 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16817 case NT_ARM_HW_WATCH:
16818 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16819 case NT_PSTATUS:
16820 return _("NT_PSTATUS (pstatus structure)");
16821 case NT_FPREGS:
16822 return _("NT_FPREGS (floating point registers)");
16823 case NT_PSINFO:
16824 return _("NT_PSINFO (psinfo structure)");
16825 case NT_LWPSTATUS:
16826 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16827 case NT_LWPSINFO:
16828 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16829 case NT_WIN32PSTATUS:
16830 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16831 case NT_SIGINFO:
16832 return _("NT_SIGINFO (siginfo_t data)");
16833 case NT_FILE:
16834 return _("NT_FILE (mapped files)");
16835 default:
16836 break;
16837 }
16838 else
16839 switch (e_type)
16840 {
16841 case NT_VERSION:
16842 return _("NT_VERSION (version)");
16843 case NT_ARCH:
16844 return _("NT_ARCH (architecture)");
16845 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16846 return _("OPEN");
16847 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16848 return _("func");
16849 default:
16850 break;
16851 }
16852
16853 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16854 return buff;
16855}
16856
16857static bfd_boolean
16858print_core_note (Elf_Internal_Note *pnote)
16859{
16860 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16861 bfd_vma count, page_size;
16862 unsigned char *descdata, *filenames, *descend;
16863
16864 if (pnote->type != NT_FILE)
16865 {
16866 if (do_wide)
16867 printf ("\n");
16868 return TRUE;
16869 }
16870
16871#ifndef BFD64
16872 if (!is_32bit_elf)
16873 {
16874 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16875 /* Still "successful". */
16876 return TRUE;
16877 }
16878#endif
16879
16880 if (pnote->descsz < 2 * addr_size)
16881 {
16882 error (_(" Malformed note - too short for header\n"));
16883 return FALSE;
16884 }
16885
16886 descdata = (unsigned char *) pnote->descdata;
16887 descend = descdata + pnote->descsz;
16888
16889 if (descdata[pnote->descsz - 1] != '\0')
16890 {
16891 error (_(" Malformed note - does not end with \\0\n"));
16892 return FALSE;
16893 }
16894
16895 count = byte_get (descdata, addr_size);
16896 descdata += addr_size;
16897
16898 page_size = byte_get (descdata, addr_size);
16899 descdata += addr_size;
16900
16901 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16902 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16903 {
16904 error (_(" Malformed note - too short for supplied file count\n"));
16905 return FALSE;
16906 }
16907
16908 printf (_(" Page size: "));
16909 print_vma (page_size, DEC);
16910 printf ("\n");
16911
16912 printf (_(" %*s%*s%*s\n"),
16913 (int) (2 + 2 * addr_size), _("Start"),
16914 (int) (4 + 2 * addr_size), _("End"),
16915 (int) (4 + 2 * addr_size), _("Page Offset"));
16916 filenames = descdata + count * 3 * addr_size;
16917 while (count-- > 0)
16918 {
16919 bfd_vma start, end, file_ofs;
16920
16921 if (filenames == descend)
16922 {
16923 error (_(" Malformed note - filenames end too early\n"));
16924 return FALSE;
16925 }
16926
16927 start = byte_get (descdata, addr_size);
16928 descdata += addr_size;
16929 end = byte_get (descdata, addr_size);
16930 descdata += addr_size;
16931 file_ofs = byte_get (descdata, addr_size);
16932 descdata += addr_size;
16933
16934 printf (" ");
16935 print_vma (start, FULL_HEX);
16936 printf (" ");
16937 print_vma (end, FULL_HEX);
16938 printf (" ");
16939 print_vma (file_ofs, FULL_HEX);
16940 printf ("\n %s\n", filenames);
16941
16942 filenames += 1 + strlen ((char *) filenames);
16943 }
16944
16945 return TRUE;
16946}
16947
16948static const char *
16949get_gnu_elf_note_type (unsigned e_type)
16950{
16951 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16952 switch (e_type)
16953 {
16954 case NT_GNU_ABI_TAG:
16955 return _("NT_GNU_ABI_TAG (ABI version tag)");
16956 case NT_GNU_HWCAP:
16957 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16958 case NT_GNU_BUILD_ID:
16959 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16960 case NT_GNU_GOLD_VERSION:
16961 return _("NT_GNU_GOLD_VERSION (gold version)");
16962 case NT_GNU_PROPERTY_TYPE_0:
16963 return _("NT_GNU_PROPERTY_TYPE_0");
16964 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16965 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16966 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16967 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16968 default:
16969 {
16970 static char buff[64];
16971
16972 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16973 return buff;
16974 }
16975 }
16976}
16977
16978static void
16979decode_x86_compat_isa (unsigned int bitmask)
16980{
16981 while (bitmask)
16982 {
16983 unsigned int bit = bitmask & (- bitmask);
16984
16985 bitmask &= ~ bit;
16986 switch (bit)
16987 {
16988 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16989 printf ("i486");
16990 break;
16991 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16992 printf ("586");
16993 break;
16994 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16995 printf ("686");
16996 break;
16997 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16998 printf ("SSE");
16999 break;
17000 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17001 printf ("SSE2");
17002 break;
17003 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17004 printf ("SSE3");
17005 break;
17006 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17007 printf ("SSSE3");
17008 break;
17009 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17010 printf ("SSE4_1");
17011 break;
17012 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17013 printf ("SSE4_2");
17014 break;
17015 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17016 printf ("AVX");
17017 break;
17018 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17019 printf ("AVX2");
17020 break;
17021 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17022 printf ("AVX512F");
17023 break;
17024 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17025 printf ("AVX512CD");
17026 break;
17027 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17028 printf ("AVX512ER");
17029 break;
17030 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17031 printf ("AVX512PF");
17032 break;
17033 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17034 printf ("AVX512VL");
17035 break;
17036 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17037 printf ("AVX512DQ");
17038 break;
17039 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17040 printf ("AVX512BW");
17041 break;
17042 default:
17043 printf (_("<unknown: %x>"), bit);
17044 break;
17045 }
17046 if (bitmask)
17047 printf (", ");
17048 }
17049}
17050
17051static void
17052decode_x86_isa (unsigned int bitmask)
17053{
17054 if (!bitmask)
17055 {
17056 printf (_("<None>"));
17057 return;
17058 }
17059
17060 while (bitmask)
17061 {
17062 unsigned int bit = bitmask & (- bitmask);
17063
17064 bitmask &= ~ bit;
17065 switch (bit)
17066 {
17067 case GNU_PROPERTY_X86_ISA_1_CMOV:
17068 printf ("CMOV");
17069 break;
17070 case GNU_PROPERTY_X86_ISA_1_SSE:
17071 printf ("SSE");
17072 break;
17073 case GNU_PROPERTY_X86_ISA_1_SSE2:
17074 printf ("SSE2");
17075 break;
17076 case GNU_PROPERTY_X86_ISA_1_SSE3:
17077 printf ("SSE3");
17078 break;
17079 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17080 printf ("SSSE3");
17081 break;
17082 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17083 printf ("SSE4_1");
17084 break;
17085 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17086 printf ("SSE4_2");
17087 break;
17088 case GNU_PROPERTY_X86_ISA_1_AVX:
17089 printf ("AVX");
17090 break;
17091 case GNU_PROPERTY_X86_ISA_1_AVX2:
17092 printf ("AVX2");
17093 break;
17094 case GNU_PROPERTY_X86_ISA_1_FMA:
17095 printf ("FMA");
17096 break;
17097 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17098 printf ("AVX512F");
17099 break;
17100 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17101 printf ("AVX512CD");
17102 break;
17103 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17104 printf ("AVX512ER");
17105 break;
17106 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17107 printf ("AVX512PF");
17108 break;
17109 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17110 printf ("AVX512VL");
17111 break;
17112 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17113 printf ("AVX512DQ");
17114 break;
17115 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17116 printf ("AVX512BW");
17117 break;
17118 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17119 printf ("AVX512_4FMAPS");
17120 break;
17121 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17122 printf ("AVX512_4VNNIW");
17123 break;
17124 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17125 printf ("AVX512_BITALG");
17126 break;
17127 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17128 printf ("AVX512_IFMA");
17129 break;
17130 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17131 printf ("AVX512_VBMI");
17132 break;
17133 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17134 printf ("AVX512_VBMI2");
17135 break;
17136 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17137 printf ("AVX512_VNNI");
17138 break;
17139 default:
17140 printf (_("<unknown: %x>"), bit);
17141 break;
17142 }
17143 if (bitmask)
17144 printf (", ");
17145 }
17146}
17147
17148static void
17149decode_x86_feature_1 (unsigned int bitmask)
17150{
17151 if (!bitmask)
17152 {
17153 printf (_("<None>"));
17154 return;
17155 }
17156
17157 while (bitmask)
17158 {
17159 unsigned int bit = bitmask & (- bitmask);
17160
17161 bitmask &= ~ bit;
17162 switch (bit)
17163 {
17164 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17165 printf ("IBT");
17166 break;
17167 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17168 printf ("SHSTK");
17169 break;
17170 default:
17171 printf (_("<unknown: %x>"), bit);
17172 break;
17173 }
17174 if (bitmask)
17175 printf (", ");
17176 }
17177}
17178
17179static void
17180decode_x86_feature_2 (unsigned int bitmask)
17181{
17182 if (!bitmask)
17183 {
17184 printf (_("<None>"));
17185 return;
17186 }
17187
17188 while (bitmask)
17189 {
17190 unsigned int bit = bitmask & (- bitmask);
17191
17192 bitmask &= ~ bit;
17193 switch (bit)
17194 {
17195 case GNU_PROPERTY_X86_FEATURE_2_X86:
17196 printf ("x86");
17197 break;
17198 case GNU_PROPERTY_X86_FEATURE_2_X87:
17199 printf ("x87");
17200 break;
17201 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17202 printf ("MMX");
17203 break;
17204 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17205 printf ("XMM");
17206 break;
17207 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17208 printf ("YMM");
17209 break;
17210 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17211 printf ("ZMM");
17212 break;
17213 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17214 printf ("FXSR");
17215 break;
17216 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17217 printf ("XSAVE");
17218 break;
17219 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17220 printf ("XSAVEOPT");
17221 break;
17222 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17223 printf ("XSAVEC");
17224 break;
17225 default:
17226 printf (_("<unknown: %x>"), bit);
17227 break;
17228 }
17229 if (bitmask)
17230 printf (", ");
17231 }
17232}
17233
17234static void
17235print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17236{
17237 unsigned char * ptr = (unsigned char *) pnote->descdata;
17238 unsigned char * ptr_end = ptr + pnote->descsz;
17239 unsigned int size = is_32bit_elf ? 4 : 8;
17240
17241 printf (_(" Properties: "));
17242
17243 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17244 {
17245 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17246 return;
17247 }
17248
17249 while (ptr < ptr_end)
17250 {
17251 unsigned int j;
17252 unsigned int type;
17253 unsigned int datasz;
17254
17255 if ((size_t) (ptr_end - ptr) < 8)
17256 {
17257 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17258 break;
17259 }
17260
17261 type = byte_get (ptr, 4);
17262 datasz = byte_get (ptr + 4, 4);
17263
17264 ptr += 8;
17265
17266 if (datasz > (size_t) (ptr_end - ptr))
17267 {
17268 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17269 type, datasz);
17270 break;
17271 }
17272
17273 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17274 {
17275 if (filedata->file_header.e_machine == EM_X86_64
17276 || filedata->file_header.e_machine == EM_IAMCU
17277 || filedata->file_header.e_machine == EM_386)
17278 {
17279 unsigned int bitmask;
17280
17281 if (datasz == 4)
17282 bitmask = byte_get (ptr, 4);
17283 else
17284 bitmask = 0;
17285
17286 switch (type)
17287 {
17288 case GNU_PROPERTY_X86_ISA_1_USED:
17289 if (datasz != 4)
17290 printf (_("x86 ISA used: <corrupt length: %#x> "),
17291 datasz);
17292 else
17293 {
17294 printf ("x86 ISA used: ");
17295 decode_x86_isa (bitmask);
17296 }
17297 goto next;
17298
17299 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17300 if (datasz != 4)
17301 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17302 datasz);
17303 else
17304 {
17305 printf ("x86 ISA needed: ");
17306 decode_x86_isa (bitmask);
17307 }
17308 goto next;
17309
17310 case GNU_PROPERTY_X86_FEATURE_1_AND:
17311 if (datasz != 4)
17312 printf (_("x86 feature: <corrupt length: %#x> "),
17313 datasz);
17314 else
17315 {
17316 printf ("x86 feature: ");
17317 decode_x86_feature_1 (bitmask);
17318 }
17319 goto next;
17320
17321 case GNU_PROPERTY_X86_FEATURE_2_USED:
17322 if (datasz != 4)
17323 printf (_("x86 feature used: <corrupt length: %#x> "),
17324 datasz);
17325 else
17326 {
17327 printf ("x86 feature used: ");
17328 decode_x86_feature_2 (bitmask);
17329 }
17330 goto next;
17331
17332 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17333 if (datasz != 4)
17334 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17335 else
17336 {
17337 printf ("x86 feature needed: ");
17338 decode_x86_feature_2 (bitmask);
17339 }
17340 goto next;
17341
17342 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17343 if (datasz != 4)
17344 printf (_("x86 ISA used: <corrupt length: %#x> "),
17345 datasz);
17346 else
17347 {
17348 printf ("x86 ISA used: ");
17349 decode_x86_compat_isa (bitmask);
17350 }
17351 goto next;
17352
17353 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17354 if (datasz != 4)
17355 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17356 datasz);
17357 else
17358 {
17359 printf ("x86 ISA needed: ");
17360 decode_x86_compat_isa (bitmask);
17361 }
17362 goto next;
17363
17364 default:
17365 break;
17366 }
17367 }
17368 }
17369 else
17370 {
17371 switch (type)
17372 {
17373 case GNU_PROPERTY_STACK_SIZE:
17374 printf (_("stack size: "));
17375 if (datasz != size)
17376 printf (_("<corrupt length: %#x> "), datasz);
17377 else
17378 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17379 goto next;
17380
17381 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17382 printf ("no copy on protected ");
17383 if (datasz)
17384 printf (_("<corrupt length: %#x> "), datasz);
17385 goto next;
17386
17387 default:
17388 break;
17389 }
17390 }
17391
17392 if (type < GNU_PROPERTY_LOPROC)
17393 printf (_("<unknown type %#x data: "), type);
17394 else if (type < GNU_PROPERTY_LOUSER)
17395 printf (_("<procesor-specific type %#x data: "), type);
17396 else
17397 printf (_("<application-specific type %#x data: "), type);
17398 for (j = 0; j < datasz; ++j)
17399 printf ("%02x ", ptr[j] & 0xff);
17400 printf (">");
17401
17402next:
17403 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17404 if (ptr == ptr_end)
17405 break;
17406
17407 if (do_wide)
17408 printf (", ");
17409 else
17410 printf ("\n\t");
17411 }
17412
17413 printf ("\n");
17414}
17415
17416static bfd_boolean
17417print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17418{
17419 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17420 switch (pnote->type)
17421 {
17422 case NT_GNU_BUILD_ID:
17423 {
17424 unsigned long i;
17425
17426 printf (_(" Build ID: "));
17427 for (i = 0; i < pnote->descsz; ++i)
17428 printf ("%02x", pnote->descdata[i] & 0xff);
17429 printf ("\n");
17430 }
17431 break;
17432
17433 case NT_GNU_ABI_TAG:
17434 {
17435 unsigned long os, major, minor, subminor;
17436 const char *osname;
17437
17438 /* PR 17531: file: 030-599401-0.004. */
17439 if (pnote->descsz < 16)
17440 {
17441 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17442 break;
17443 }
17444
17445 os = byte_get ((unsigned char *) pnote->descdata, 4);
17446 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17447 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17448 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17449
17450 switch (os)
17451 {
17452 case GNU_ABI_TAG_LINUX:
17453 osname = "Linux";
17454 break;
17455 case GNU_ABI_TAG_HURD:
17456 osname = "Hurd";
17457 break;
17458 case GNU_ABI_TAG_SOLARIS:
17459 osname = "Solaris";
17460 break;
17461 case GNU_ABI_TAG_FREEBSD:
17462 osname = "FreeBSD";
17463 break;
17464 case GNU_ABI_TAG_NETBSD:
17465 osname = "NetBSD";
17466 break;
17467 case GNU_ABI_TAG_SYLLABLE:
17468 osname = "Syllable";
17469 break;
17470 case GNU_ABI_TAG_NACL:
17471 osname = "NaCl";
17472 break;
17473 default:
17474 osname = "Unknown";
17475 break;
17476 }
17477
17478 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17479 major, minor, subminor);
17480 }
17481 break;
17482
17483 case NT_GNU_GOLD_VERSION:
17484 {
17485 unsigned long i;
17486
17487 printf (_(" Version: "));
17488 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17489 printf ("%c", pnote->descdata[i]);
17490 printf ("\n");
17491 }
17492 break;
17493
17494 case NT_GNU_HWCAP:
17495 {
17496 unsigned long num_entries, mask;
17497
17498 /* Hardware capabilities information. Word 0 is the number of entries.
17499 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17500 is a series of entries, where each entry is a single byte followed
17501 by a nul terminated string. The byte gives the bit number to test
17502 if enabled in the bitmask. */
17503 printf (_(" Hardware Capabilities: "));
17504 if (pnote->descsz < 8)
17505 {
17506 error (_("<corrupt GNU_HWCAP>\n"));
17507 return FALSE;
17508 }
17509 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17510 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17511 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17512 /* FIXME: Add code to display the entries... */
17513 }
17514 break;
17515
17516 case NT_GNU_PROPERTY_TYPE_0:
17517 print_gnu_property_note (filedata, pnote);
17518 break;
17519
17520 default:
17521 /* Handle unrecognised types. An error message should have already been
17522 created by get_gnu_elf_note_type(), so all that we need to do is to
17523 display the data. */
17524 {
17525 unsigned long i;
17526
17527 printf (_(" Description data: "));
17528 for (i = 0; i < pnote->descsz; ++i)
17529 printf ("%02x ", pnote->descdata[i] & 0xff);
17530 printf ("\n");
17531 }
17532 break;
17533 }
17534
17535 return TRUE;
17536}
17537
17538static const char *
17539get_v850_elf_note_type (enum v850_notes n_type)
17540{
17541 static char buff[64];
17542
17543 switch (n_type)
17544 {
17545 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17546 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17547 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17548 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17549 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17550 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17551 default:
17552 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17553 return buff;
17554 }
17555}
17556
17557static bfd_boolean
17558print_v850_note (Elf_Internal_Note * pnote)
17559{
17560 unsigned int val;
17561
17562 if (pnote->descsz != 4)
17563 return FALSE;
17564
17565 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17566
17567 if (val == 0)
17568 {
17569 printf (_("not set\n"));
17570 return TRUE;
17571 }
17572
17573 switch (pnote->type)
17574 {
17575 case V850_NOTE_ALIGNMENT:
17576 switch (val)
17577 {
17578 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17579 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17580 }
17581 break;
17582
17583 case V850_NOTE_DATA_SIZE:
17584 switch (val)
17585 {
17586 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17587 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17588 }
17589 break;
17590
17591 case V850_NOTE_FPU_INFO:
17592 switch (val)
17593 {
17594 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17595 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17596 }
17597 break;
17598
17599 case V850_NOTE_MMU_INFO:
17600 case V850_NOTE_CACHE_INFO:
17601 case V850_NOTE_SIMD_INFO:
17602 if (val == EF_RH850_SIMD)
17603 {
17604 printf (_("yes\n"));
17605 return TRUE;
17606 }
17607 break;
17608
17609 default:
17610 /* An 'unknown note type' message will already have been displayed. */
17611 break;
17612 }
17613
17614 printf (_("unknown value: %x\n"), val);
17615 return FALSE;
17616}
17617
17618static bfd_boolean
17619process_netbsd_elf_note (Elf_Internal_Note * pnote)
17620{
17621 unsigned int version;
17622
17623 switch (pnote->type)
17624 {
17625 case NT_NETBSD_IDENT:
17626 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17627 if ((version / 10000) % 100)
17628 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17629 version, version / 100000000, (version / 1000000) % 100,
17630 (version / 10000) % 100 > 26 ? "Z" : "",
17631 'A' + (version / 10000) % 26);
17632 else
17633 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17634 version, version / 100000000, (version / 1000000) % 100,
17635 (version / 100) % 100);
17636 return TRUE;
17637
17638 case NT_NETBSD_MARCH:
17639 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17640 pnote->descdata);
17641 return TRUE;
17642
17643 default:
17644 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17645 pnote->type);
17646 return FALSE;
17647 }
17648}
17649
17650static const char *
17651get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17652{
17653 switch (e_type)
17654 {
17655 case NT_FREEBSD_THRMISC:
17656 return _("NT_THRMISC (thrmisc structure)");
17657 case NT_FREEBSD_PROCSTAT_PROC:
17658 return _("NT_PROCSTAT_PROC (proc data)");
17659 case NT_FREEBSD_PROCSTAT_FILES:
17660 return _("NT_PROCSTAT_FILES (files data)");
17661 case NT_FREEBSD_PROCSTAT_VMMAP:
17662 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17663 case NT_FREEBSD_PROCSTAT_GROUPS:
17664 return _("NT_PROCSTAT_GROUPS (groups data)");
17665 case NT_FREEBSD_PROCSTAT_UMASK:
17666 return _("NT_PROCSTAT_UMASK (umask data)");
17667 case NT_FREEBSD_PROCSTAT_RLIMIT:
17668 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17669 case NT_FREEBSD_PROCSTAT_OSREL:
17670 return _("NT_PROCSTAT_OSREL (osreldate data)");
17671 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17672 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17673 case NT_FREEBSD_PROCSTAT_AUXV:
17674 return _("NT_PROCSTAT_AUXV (auxv data)");
17675 case NT_FREEBSD_PTLWPINFO:
17676 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17677 }
17678 return get_note_type (filedata, e_type);
17679}
17680
17681static const char *
17682get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17683{
17684 static char buff[64];
17685
17686 if (e_type == NT_NETBSDCORE_PROCINFO)
17687 return _("NetBSD procinfo structure");
17688
17689 /* As of Jan 2002 there are no other machine-independent notes
17690 defined for NetBSD core files. If the note type is less
17691 than the start of the machine-dependent note types, we don't
17692 understand it. */
17693
17694 if (e_type < NT_NETBSDCORE_FIRSTMACH)
17695 {
17696 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17697 return buff;
17698 }
17699
17700 switch (filedata->file_header.e_machine)
17701 {
17702 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17703 and PT_GETFPREGS == mach+2. */
17704
17705 case EM_OLD_ALPHA:
17706 case EM_ALPHA:
17707 case EM_SPARC:
17708 case EM_SPARC32PLUS:
17709 case EM_SPARCV9:
17710 switch (e_type)
17711 {
17712 case NT_NETBSDCORE_FIRSTMACH + 0:
17713 return _("PT_GETREGS (reg structure)");
17714 case NT_NETBSDCORE_FIRSTMACH + 2:
17715 return _("PT_GETFPREGS (fpreg structure)");
17716 default:
17717 break;
17718 }
17719 break;
17720
17721 /* On all other arch's, PT_GETREGS == mach+1 and
17722 PT_GETFPREGS == mach+3. */
17723 default:
17724 switch (e_type)
17725 {
17726 case NT_NETBSDCORE_FIRSTMACH + 1:
17727 return _("PT_GETREGS (reg structure)");
17728 case NT_NETBSDCORE_FIRSTMACH + 3:
17729 return _("PT_GETFPREGS (fpreg structure)");
17730 default:
17731 break;
17732 }
17733 }
17734
17735 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17736 e_type - NT_NETBSDCORE_FIRSTMACH);
17737 return buff;
17738}
17739
17740static const char *
17741get_stapsdt_note_type (unsigned e_type)
17742{
17743 static char buff[64];
17744
17745 switch (e_type)
17746 {
17747 case NT_STAPSDT:
17748 return _("NT_STAPSDT (SystemTap probe descriptors)");
17749
17750 default:
17751 break;
17752 }
17753
17754 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17755 return buff;
17756}
17757
17758static bfd_boolean
17759print_stapsdt_note (Elf_Internal_Note *pnote)
17760{
17761 int addr_size = is_32bit_elf ? 4 : 8;
17762 char *data = pnote->descdata;
17763 char *data_end = pnote->descdata + pnote->descsz;
17764 bfd_vma pc, base_addr, semaphore;
17765 char *provider, *probe, *arg_fmt;
17766
17767 pc = byte_get ((unsigned char *) data, addr_size);
17768 data += addr_size;
17769 base_addr = byte_get ((unsigned char *) data, addr_size);
17770 data += addr_size;
17771 semaphore = byte_get ((unsigned char *) data, addr_size);
17772 data += addr_size;
17773
17774 provider = data;
17775 data += strlen (data) + 1;
17776 probe = data;
17777 data += strlen (data) + 1;
17778 arg_fmt = data;
17779 data += strlen (data) + 1;
17780
17781 printf (_(" Provider: %s\n"), provider);
17782 printf (_(" Name: %s\n"), probe);
17783 printf (_(" Location: "));
17784 print_vma (pc, FULL_HEX);
17785 printf (_(", Base: "));
17786 print_vma (base_addr, FULL_HEX);
17787 printf (_(", Semaphore: "));
17788 print_vma (semaphore, FULL_HEX);
17789 printf ("\n");
17790 printf (_(" Arguments: %s\n"), arg_fmt);
17791
17792 return data == data_end;
17793}
17794
17795static const char *
17796get_ia64_vms_note_type (unsigned e_type)
17797{
17798 static char buff[64];
17799
17800 switch (e_type)
17801 {
17802 case NT_VMS_MHD:
17803 return _("NT_VMS_MHD (module header)");
17804 case NT_VMS_LNM:
17805 return _("NT_VMS_LNM (language name)");
17806 case NT_VMS_SRC:
17807 return _("NT_VMS_SRC (source files)");
17808 case NT_VMS_TITLE:
17809 return "NT_VMS_TITLE";
17810 case NT_VMS_EIDC:
17811 return _("NT_VMS_EIDC (consistency check)");
17812 case NT_VMS_FPMODE:
17813 return _("NT_VMS_FPMODE (FP mode)");
17814 case NT_VMS_LINKTIME:
17815 return "NT_VMS_LINKTIME";
17816 case NT_VMS_IMGNAM:
17817 return _("NT_VMS_IMGNAM (image name)");
17818 case NT_VMS_IMGID:
17819 return _("NT_VMS_IMGID (image id)");
17820 case NT_VMS_LINKID:
17821 return _("NT_VMS_LINKID (link id)");
17822 case NT_VMS_IMGBID:
17823 return _("NT_VMS_IMGBID (build id)");
17824 case NT_VMS_GSTNAM:
17825 return _("NT_VMS_GSTNAM (sym table name)");
17826 case NT_VMS_ORIG_DYN:
17827 return "NT_VMS_ORIG_DYN";
17828 case NT_VMS_PATCHTIME:
17829 return "NT_VMS_PATCHTIME";
17830 default:
17831 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17832 return buff;
17833 }
17834}
17835
17836static bfd_boolean
17837print_ia64_vms_note (Elf_Internal_Note * pnote)
17838{
17839 switch (pnote->type)
17840 {
17841 case NT_VMS_MHD:
17842 if (pnote->descsz > 36)
17843 {
17844 size_t l = strlen (pnote->descdata + 34);
17845 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17846 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17847 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17848 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17849 }
17850 else
17851 printf (_(" Invalid size\n"));
17852 break;
17853 case NT_VMS_LNM:
17854 printf (_(" Language: %s\n"), pnote->descdata);
17855 break;
17856#ifdef BFD64
17857 case NT_VMS_FPMODE:
17858 printf (_(" Floating Point mode: "));
17859 printf ("0x%016" BFD_VMA_FMT "x\n",
17860 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17861 break;
17862 case NT_VMS_LINKTIME:
17863 printf (_(" Link time: "));
17864 print_vms_time
17865 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17866 printf ("\n");
17867 break;
17868 case NT_VMS_PATCHTIME:
17869 printf (_(" Patch time: "));
17870 print_vms_time
17871 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17872 printf ("\n");
17873 break;
17874 case NT_VMS_ORIG_DYN:
17875 printf (_(" Major id: %u, minor id: %u\n"),
17876 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17877 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17878 printf (_(" Last modified : "));
17879 print_vms_time
17880 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17881 printf (_("\n Link flags : "));
17882 printf ("0x%016" BFD_VMA_FMT "x\n",
17883 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17884 printf (_(" Header flags: 0x%08x\n"),
17885 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17886 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17887 break;
17888#endif
17889 case NT_VMS_IMGNAM:
17890 printf (_(" Image name: %s\n"), pnote->descdata);
17891 break;
17892 case NT_VMS_GSTNAM:
17893 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17894 break;
17895 case NT_VMS_IMGID:
17896 printf (_(" Image id: %s\n"), pnote->descdata);
17897 break;
17898 case NT_VMS_LINKID:
17899 printf (_(" Linker id: %s\n"), pnote->descdata);
17900 break;
17901 default:
17902 return FALSE;
17903 }
17904 return TRUE;
17905}
17906
17907/* Find the symbol associated with a build attribute that is attached
17908 to address OFFSET. If PNAME is non-NULL then store the name of
17909 the symbol (if found) in the provided pointer, Returns NULL if a
17910 symbol could not be found. */
17911
17912static Elf_Internal_Sym *
17913get_symbol_for_build_attribute (Filedata * filedata,
17914 unsigned long offset,
17915 bfd_boolean is_open_attr,
17916 const char ** pname)
17917{
17918 static Filedata * saved_filedata = NULL;
17919 static char * strtab;
17920 static unsigned long strtablen;
17921 static Elf_Internal_Sym * symtab;
17922 static unsigned long nsyms;
17923 Elf_Internal_Sym * saved_sym = NULL;
17924 Elf_Internal_Sym * sym;
17925
17926 if (filedata->section_headers != NULL
17927 && (saved_filedata == NULL || filedata != saved_filedata))
17928 {
17929 Elf_Internal_Shdr * symsec;
17930
17931 /* Load the symbol and string sections. */
17932 for (symsec = filedata->section_headers;
17933 symsec < filedata->section_headers + filedata->file_header.e_shnum;
17934 symsec ++)
17935 {
17936 if (symsec->sh_type == SHT_SYMTAB)
17937 {
17938 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17939
17940 if (symsec->sh_link < filedata->file_header.e_shnum)
17941 {
17942 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17943
17944 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17945 1, strtab_sec->sh_size,
17946 _("string table"));
17947 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17948 }
17949 }
17950 }
17951 saved_filedata = filedata;
17952 }
17953
17954 if (symtab == NULL || strtab == NULL)
17955 return NULL;
17956
17957 /* Find a symbol whose value matches offset. */
17958 for (sym = symtab; sym < symtab + nsyms; sym ++)
17959 if (sym->st_value == offset)
17960 {
17961 if (sym->st_name >= strtablen)
17962 /* Huh ? This should not happen. */
17963 continue;
17964
17965 if (strtab[sym->st_name] == 0)
17966 continue;
17967
17968 /* The AArch64 and ARM architectures define mapping symbols
17969 (eg $d, $x, $t) which we want to ignore. */
17970 if (strtab[sym->st_name] == '$'
17971 && strtab[sym->st_name + 1] != 0
17972 && strtab[sym->st_name + 2] == 0)
17973 continue;
17974
17975 if (is_open_attr)
17976 {
17977 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17978 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17979 FUNC symbols entirely. */
17980 switch (ELF_ST_TYPE (sym->st_info))
17981 {
17982 case STT_OBJECT:
17983 case STT_FILE:
17984 saved_sym = sym;
17985 if (sym->st_size)
17986 {
17987 /* If the symbol has a size associated
17988 with it then we can stop searching. */
17989 sym = symtab + nsyms;
17990 }
17991 continue;
17992
17993 case STT_FUNC:
17994 /* Ignore function symbols. */
17995 continue;
17996
17997 default:
17998 break;
17999 }
18000
18001 switch (ELF_ST_BIND (sym->st_info))
18002 {
18003 case STB_GLOBAL:
18004 if (saved_sym == NULL
18005 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18006 saved_sym = sym;
18007 break;
18008
18009 case STB_LOCAL:
18010 if (saved_sym == NULL)
18011 saved_sym = sym;
18012 break;
18013
18014 default:
18015 break;
18016 }
18017 }
18018 else
18019 {
18020 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18021 continue;
18022
18023 saved_sym = sym;
18024 break;
18025 }
18026 }
18027
18028 if (saved_sym && pname)
18029 * pname = strtab + saved_sym->st_name;
18030
18031 return saved_sym;
18032}
18033
18034/* Returns true iff addr1 and addr2 are in the same section. */
18035
18036static bfd_boolean
18037same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18038{
18039 Elf_Internal_Shdr * a1;
18040 Elf_Internal_Shdr * a2;
18041
18042 a1 = find_section_by_address (filedata, addr1);
18043 a2 = find_section_by_address (filedata, addr2);
18044
18045 return a1 == a2 && a1 != NULL;
18046}
18047
18048static bfd_boolean
18049print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18050 Filedata * filedata)
18051{
18052 static unsigned long global_offset = 0;
18053 static unsigned long global_end = 0;
18054 static unsigned long func_offset = 0;
18055 static unsigned long func_end = 0;
18056
18057 Elf_Internal_Sym * sym;
18058 const char * name;
18059 unsigned long start;
18060 unsigned long end;
18061 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18062
18063 switch (pnote->descsz)
18064 {
18065 case 0:
18066 /* A zero-length description means that the range of
18067 the previous note of the same type should be used. */
18068 if (is_open_attr)
18069 {
18070 if (global_end > global_offset)
18071 printf (_(" Applies to region from %#lx to %#lx\n"),
18072 global_offset, global_end);
18073 else
18074 printf (_(" Applies to region from %#lx\n"), global_offset);
18075 }
18076 else
18077 {
18078 if (func_end > func_offset)
18079 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18080 else
18081 printf (_(" Applies to region from %#lx\n"), func_offset);
18082 }
18083 return TRUE;
18084
18085 case 4:
18086 start = byte_get ((unsigned char *) pnote->descdata, 4);
18087 end = 0;
18088 break;
18089
18090 case 8:
18091 if (is_32bit_elf)
18092 {
18093 /* FIXME: We should check that version 3+ notes are being used here... */
18094 start = byte_get ((unsigned char *) pnote->descdata, 4);
18095 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18096 }
18097 else
18098 {
18099 start = byte_get ((unsigned char *) pnote->descdata, 8);
18100 end = 0;
18101 }
18102 break;
18103
18104 case 16:
18105 start = byte_get ((unsigned char *) pnote->descdata, 8);
18106 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18107 break;
18108
18109 default:
18110 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18111 printf (_(" <invalid descsz>"));
18112 return FALSE;
18113 }
18114
18115 name = NULL;
18116 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18117 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18118 in order to avoid them being confused with the start address of the
18119 first function in the file... */
18120 if (sym == NULL && is_open_attr)
18121 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18122 & name);
18123
18124 if (end == 0 && sym != NULL && sym->st_size > 0)
18125 end = start + sym->st_size;
18126
18127 if (is_open_attr)
18128 {
18129 /* FIXME: Need to properly allow for section alignment.
18130 16 is just the alignment used on x86_64. */
18131 if (global_end > 0
18132 && start > BFD_ALIGN (global_end, 16)
18133 /* Build notes are not guaranteed to be organised in order of
18134 increasing address, but we should find the all of the notes
18135 for one section in the same place. */
18136 && same_section (filedata, start, global_end))
18137 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18138 global_end + 1, start - 1);
18139
18140 printf (_(" Applies to region from %#lx"), start);
18141 global_offset = start;
18142
18143 if (end)
18144 {
18145 printf (_(" to %#lx"), end);
18146 global_end = end;
18147 }
18148 }
18149 else
18150 {
18151 printf (_(" Applies to region from %#lx"), start);
18152 func_offset = start;
18153
18154 if (end)
18155 {
18156 printf (_(" to %#lx"), end);
18157 func_end = end;
18158 }
18159 }
18160
18161 if (sym && name)
18162 printf (_(" (%s)"), name);
18163
18164 printf ("\n");
18165 return TRUE;
18166}
18167
18168static bfd_boolean
18169print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18170{
18171 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18172 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18173 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18174 char name_type;
18175 char name_attribute;
18176 const char * expected_types;
18177 const char * name = pnote->namedata;
18178 const char * text;
18179 signed int left;
18180
18181 if (name == NULL || pnote->namesz < 2)
18182 {
18183 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18184 print_symbol (-20, _(" <corrupt name>"));
18185 return FALSE;
18186 }
18187
18188 if (do_wide)
18189 left = 28;
18190 else
18191 left = 20;
18192
18193 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18194 if (name[0] == 'G' && name[1] == 'A')
18195 {
18196 if (pnote->namesz < 4)
18197 {
18198 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18199 print_symbol (-20, _(" <corrupt name>"));
18200 return FALSE;
18201 }
18202
18203 printf ("GA");
18204 name += 2;
18205 left -= 2;
18206 }
18207
18208 switch ((name_type = * name))
18209 {
18210 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18211 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18212 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18213 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18214 printf ("%c", * name);
18215 left --;
18216 break;
18217 default:
18218 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18219 print_symbol (-20, _("<unknown name type>"));
18220 return FALSE;
18221 }
18222
18223 ++ name;
18224 text = NULL;
18225
18226 switch ((name_attribute = * name))
18227 {
18228 case GNU_BUILD_ATTRIBUTE_VERSION:
18229 text = _("<version>");
18230 expected_types = string_expected;
18231 ++ name;
18232 break;
18233 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18234 text = _("<stack prot>");
18235 expected_types = "!+*";
18236 ++ name;
18237 break;
18238 case GNU_BUILD_ATTRIBUTE_RELRO:
18239 text = _("<relro>");
18240 expected_types = bool_expected;
18241 ++ name;
18242 break;
18243 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18244 text = _("<stack size>");
18245 expected_types = number_expected;
18246 ++ name;
18247 break;
18248 case GNU_BUILD_ATTRIBUTE_TOOL:
18249 text = _("<tool>");
18250 expected_types = string_expected;
18251 ++ name;
18252 break;
18253 case GNU_BUILD_ATTRIBUTE_ABI:
18254 text = _("<ABI>");
18255 expected_types = "$*";
18256 ++ name;
18257 break;
18258 case GNU_BUILD_ATTRIBUTE_PIC:
18259 text = _("<PIC>");
18260 expected_types = number_expected;
18261 ++ name;
18262 break;
18263 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18264 text = _("<short enum>");
18265 expected_types = bool_expected;
18266 ++ name;
18267 break;
18268 default:
18269 if (ISPRINT (* name))
18270 {
18271 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18272
18273 if (len > left && ! do_wide)
18274 len = left;
18275 printf ("%.*s:", len, name);
18276 left -= len;
18277 name += len;
18278 }
18279 else
18280 {
18281 static char tmpbuf [128];
18282
18283 error (_("unrecognised byte in name field: %d\n"), * name);
18284 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18285 text = tmpbuf;
18286 name ++;
18287 }
18288 expected_types = "*$!+";
18289 break;
18290 }
18291
18292 if (text)
18293 left -= printf ("%s", text);
18294
18295 if (strchr (expected_types, name_type) == NULL)
18296 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18297
18298 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18299 {
18300 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18301 (unsigned long) pnote->namesz,
18302 (long) (name - pnote->namedata));
18303 return FALSE;
18304 }
18305
18306 if (left < 1 && ! do_wide)
18307 return TRUE;
18308
18309 switch (name_type)
18310 {
18311 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18312 {
18313 unsigned int bytes;
18314 unsigned long long val = 0;
18315 unsigned int shift = 0;
18316 char * decoded = NULL;
18317
18318 bytes = pnote->namesz - (name - pnote->namedata);
18319 if (bytes > 0)
18320 /* The -1 is because the name field is always 0 terminated, and we
18321 want to be able to ensure that the shift in the while loop below
18322 will not overflow. */
18323 -- bytes;
18324
18325 if (bytes > sizeof (val))
18326 {
18327 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18328 bytes);
18329 bytes = sizeof (val);
18330 }
18331 /* We do not bother to warn if bytes == 0 as this can
18332 happen with some early versions of the gcc plugin. */
18333
18334 while (bytes --)
18335 {
18336 unsigned long byte = (* name ++) & 0xff;
18337
18338 val |= byte << shift;
18339 shift += 8;
18340 }
18341
18342 switch (name_attribute)
18343 {
18344 case GNU_BUILD_ATTRIBUTE_PIC:
18345 switch (val)
18346 {
18347 case 0: decoded = "static"; break;
18348 case 1: decoded = "pic"; break;
18349 case 2: decoded = "PIC"; break;
18350 case 3: decoded = "pie"; break;
18351 case 4: decoded = "PIE"; break;
18352 default: break;
18353 }
18354 break;
18355 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18356 switch (val)
18357 {
18358 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18359 case 0: decoded = "off"; break;
18360 case 1: decoded = "on"; break;
18361 case 2: decoded = "all"; break;
18362 case 3: decoded = "strong"; break;
18363 case 4: decoded = "explicit"; break;
18364 default: break;
18365 }
18366 break;
18367 default:
18368 break;
18369 }
18370
18371 if (decoded != NULL)
18372 {
18373 print_symbol (-left, decoded);
18374 left = 0;
18375 }
18376 else if (val == 0)
18377 {
18378 printf ("0x0");
18379 left -= 3;
18380 }
18381 else
18382 {
18383 if (do_wide)
18384 left -= printf ("0x%llx", val);
18385 else
18386 left -= printf ("0x%-.*llx", left, val);
18387 }
18388 }
18389 break;
18390 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18391 left -= print_symbol (- left, name);
18392 break;
18393 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18394 left -= print_symbol (- left, "true");
18395 break;
18396 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18397 left -= print_symbol (- left, "false");
18398 break;
18399 }
18400
18401 if (do_wide && left > 0)
18402 printf ("%-*s", left, " ");
18403
18404 return TRUE;
18405}
18406
18407/* Note that by the ELF standard, the name field is already null byte
18408 terminated, and namesz includes the terminating null byte.
18409 I.E. the value of namesz for the name "FSF" is 4.
18410
18411 If the value of namesz is zero, there is no name present. */
18412
18413static bfd_boolean
18414process_note (Elf_Internal_Note * pnote,
18415 Filedata * filedata)
18416{
18417 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18418 const char * nt;
18419
18420 if (pnote->namesz == 0)
18421 /* If there is no note name, then use the default set of
18422 note type strings. */
18423 nt = get_note_type (filedata, pnote->type);
18424
18425 else if (const_strneq (pnote->namedata, "GNU"))
18426 /* GNU-specific object file notes. */
18427 nt = get_gnu_elf_note_type (pnote->type);
18428
18429 else if (const_strneq (pnote->namedata, "FreeBSD"))
18430 /* FreeBSD-specific core file notes. */
18431 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18432
18433 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18434 /* NetBSD-specific core file notes. */
18435 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18436
18437 else if (const_strneq (pnote->namedata, "NetBSD"))
18438 /* NetBSD-specific core file notes. */
18439 return process_netbsd_elf_note (pnote);
18440
18441 else if (strneq (pnote->namedata, "SPU/", 4))
18442 {
18443 /* SPU-specific core file notes. */
18444 nt = pnote->namedata + 4;
18445 name = "SPU";
18446 }
18447
18448 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18449 /* VMS/ia64-specific file notes. */
18450 nt = get_ia64_vms_note_type (pnote->type);
18451
18452 else if (const_strneq (pnote->namedata, "stapsdt"))
18453 nt = get_stapsdt_note_type (pnote->type);
18454
18455 else
18456 /* Don't recognize this note name; just use the default set of
18457 note type strings. */
18458 nt = get_note_type (filedata, pnote->type);
18459
18460 printf (" ");
18461
18462 if (((const_strneq (pnote->namedata, "GA")
18463 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18464 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18465 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18466 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18467 print_gnu_build_attribute_name (pnote);
18468 else
18469 print_symbol (-20, name);
18470
18471 if (do_wide)
18472 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18473 else
18474 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18475
18476 if (const_strneq (pnote->namedata, "IPF/VMS"))
18477 return print_ia64_vms_note (pnote);
18478 else if (const_strneq (pnote->namedata, "GNU"))
18479 return print_gnu_note (filedata, pnote);
18480 else if (const_strneq (pnote->namedata, "stapsdt"))
18481 return print_stapsdt_note (pnote);
18482 else if (const_strneq (pnote->namedata, "CORE"))
18483 return print_core_note (pnote);
18484 else if (((const_strneq (pnote->namedata, "GA")
18485 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18486 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18487 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18488 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18489 return print_gnu_build_attribute_description (pnote, filedata);
18490
18491 if (pnote->descsz)
18492 {
18493 unsigned long i;
18494
18495 printf (_(" description data: "));
18496 for (i = 0; i < pnote->descsz; i++)
18497 printf ("%02x ", pnote->descdata[i]);
18498 if (!do_wide)
18499 printf ("\n");
18500 }
18501
18502 if (do_wide)
18503 printf ("\n");
18504
18505 return TRUE;
18506}
18507
18508static bfd_boolean
18509process_notes_at (Filedata * filedata,
18510 Elf_Internal_Shdr * section,
18511 bfd_vma offset,
18512 bfd_vma length,
18513 bfd_vma align)
18514{
18515 Elf_External_Note * pnotes;
18516 Elf_External_Note * external;
18517 char * end;
18518 bfd_boolean res = TRUE;
18519
18520 if (length <= 0)
18521 return FALSE;
18522
18523 if (section)
18524 {
18525 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18526 if (pnotes)
18527 {
18528 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18529 return FALSE;
18530 }
18531 }
18532 else
18533 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18534 _("notes"));
18535
18536 if (pnotes == NULL)
18537 return FALSE;
18538
18539 external = pnotes;
18540
18541 if (section)
18542 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18543 else
18544 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18545 (unsigned long) offset, (unsigned long) length);
18546
18547 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18548 specifies that notes should be aligned to 4 bytes in 32-bit
18549 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18550 we also support 4 byte alignment in 64-bit objects. If section
18551 alignment is less than 4, we treate alignment as 4 bytes. */
18552 if (align < 4)
18553 align = 4;
18554 else if (align != 4 && align != 8)
18555 {
18556 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18557 (long) align);
18558 return FALSE;
18559 }
18560
18561 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18562
18563 end = (char *) pnotes + length;
18564 while ((char *) external < end)
18565 {
18566 Elf_Internal_Note inote;
18567 size_t min_notesz;
18568 char * next;
18569 char * temp = NULL;
18570 size_t data_remaining = end - (char *) external;
18571
18572 if (!is_ia64_vms (filedata))
18573 {
18574 /* PR binutils/15191
18575 Make sure that there is enough data to read. */
18576 min_notesz = offsetof (Elf_External_Note, name);
18577 if (data_remaining < min_notesz)
18578 {
18579 warn (ngettext ("Corrupt note: only %ld byte remains, "
18580 "not enough for a full note\n",
18581 "Corrupt note: only %ld bytes remain, "
18582 "not enough for a full note\n",
18583 data_remaining),
18584 (long) data_remaining);
18585 break;
18586 }
18587 data_remaining -= min_notesz;
18588
18589 inote.type = BYTE_GET (external->type);
18590 inote.namesz = BYTE_GET (external->namesz);
18591 inote.namedata = external->name;
18592 inote.descsz = BYTE_GET (external->descsz);
18593 inote.descdata = ((char *) external
18594 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18595 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18596 next = ((char *) external
18597 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18598 }
18599 else
18600 {
18601 Elf64_External_VMS_Note *vms_external;
18602
18603 /* PR binutils/15191
18604 Make sure that there is enough data to read. */
18605 min_notesz = offsetof (Elf64_External_VMS_Note, name);
18606 if (data_remaining < min_notesz)
18607 {
18608 warn (ngettext ("Corrupt note: only %ld byte remains, "
18609 "not enough for a full note\n",
18610 "Corrupt note: only %ld bytes remain, "
18611 "not enough for a full note\n",
18612 data_remaining),
18613 (long) data_remaining);
18614 break;
18615 }
18616 data_remaining -= min_notesz;
18617
18618 vms_external = (Elf64_External_VMS_Note *) external;
18619 inote.type = BYTE_GET (vms_external->type);
18620 inote.namesz = BYTE_GET (vms_external->namesz);
18621 inote.namedata = vms_external->name;
18622 inote.descsz = BYTE_GET (vms_external->descsz);
18623 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18624 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18625 next = inote.descdata + align_power (inote.descsz, 3);
18626 }
18627
18628 /* PR 17531: file: 3443835e. */
18629 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18630 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18631 || (size_t) (inote.descdata - inote.namedata) > data_remaining
18632 || (size_t) (next - inote.descdata) < inote.descsz
18633 || ((size_t) (next - inote.descdata)
18634 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18635 {
18636 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18637 (unsigned long) ((char *) external - (char *) pnotes));
18638 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18639 inote.type, inote.namesz, inote.descsz, (int) align);
18640 break;
18641 }
18642
18643 external = (Elf_External_Note *) next;
18644
18645 /* Verify that name is null terminated. It appears that at least
18646 one version of Linux (RedHat 6.0) generates corefiles that don't
18647 comply with the ELF spec by failing to include the null byte in
18648 namesz. */
18649 if (inote.namedata[inote.namesz - 1] != '\0')
18650 {
18651 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18652 {
18653 temp = (char *) malloc (inote.namesz + 1);
18654 if (temp == NULL)
18655 {
18656 error (_("Out of memory allocating space for inote name\n"));
18657 res = FALSE;
18658 break;
18659 }
18660
18661 memcpy (temp, inote.namedata, inote.namesz);
18662 inote.namedata = temp;
18663 }
18664 inote.namedata[inote.namesz] = 0;
18665 }
18666
18667 if (! process_note (& inote, filedata))
18668 res = FALSE;
18669
18670 if (temp != NULL)
18671 {
18672 free (temp);
18673 temp = NULL;
18674 }
18675 }
18676
18677 free (pnotes);
18678
18679 return res;
18680}
18681
18682static bfd_boolean
18683process_corefile_note_segments (Filedata * filedata)
18684{
18685 Elf_Internal_Phdr * segment;
18686 unsigned int i;
18687 bfd_boolean res = TRUE;
18688
18689 if (! get_program_headers (filedata))
18690 return TRUE;
18691
18692 for (i = 0, segment = filedata->program_headers;
18693 i < filedata->file_header.e_phnum;
18694 i++, segment++)
18695 {
18696 if (segment->p_type == PT_NOTE)
18697 if (! process_notes_at (filedata, NULL,
18698 (bfd_vma) segment->p_offset,
18699 (bfd_vma) segment->p_filesz,
18700 (bfd_vma) segment->p_align))
18701 res = FALSE;
18702 }
18703
18704 return res;
18705}
18706
18707static bfd_boolean
18708process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18709{
18710 Elf_External_Note * pnotes;
18711 Elf_External_Note * external;
18712 char * end;
18713 bfd_boolean res = TRUE;
18714
18715 if (length <= 0)
18716 return FALSE;
18717
18718 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18719 _("v850 notes"));
18720 if (pnotes == NULL)
18721 return FALSE;
18722
18723 external = pnotes;
18724 end = (char*) pnotes + length;
18725
18726 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18727 (unsigned long) offset, (unsigned long) length);
18728
18729 while ((char *) external + sizeof (Elf_External_Note) < end)
18730 {
18731 Elf_External_Note * next;
18732 Elf_Internal_Note inote;
18733
18734 inote.type = BYTE_GET (external->type);
18735 inote.namesz = BYTE_GET (external->namesz);
18736 inote.namedata = external->name;
18737 inote.descsz = BYTE_GET (external->descsz);
18738 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18739 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18740
18741 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18742 {
18743 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18744 inote.descdata = inote.namedata;
18745 inote.namesz = 0;
18746 }
18747
18748 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18749
18750 if ( ((char *) next > end)
18751 || ((char *) next < (char *) pnotes))
18752 {
18753 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18754 (unsigned long) ((char *) external - (char *) pnotes));
18755 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18756 inote.type, inote.namesz, inote.descsz);
18757 break;
18758 }
18759
18760 external = next;
18761
18762 /* Prevent out-of-bounds indexing. */
18763 if ( inote.namedata + inote.namesz > end
18764 || inote.namedata + inote.namesz < inote.namedata)
18765 {
18766 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18767 (unsigned long) ((char *) external - (char *) pnotes));
18768 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18769 inote.type, inote.namesz, inote.descsz);
18770 break;
18771 }
18772
18773 printf (" %s: ", get_v850_elf_note_type (inote.type));
18774
18775 if (! print_v850_note (& inote))
18776 {
18777 res = FALSE;
18778 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18779 inote.namesz, inote.descsz);
18780 }
18781 }
18782
18783 free (pnotes);
18784
18785 return res;
18786}
18787
18788static bfd_boolean
18789process_note_sections (Filedata * filedata)
18790{
18791 Elf_Internal_Shdr * section;
18792 unsigned long i;
18793 unsigned int n = 0;
18794 bfd_boolean res = TRUE;
18795
18796 for (i = 0, section = filedata->section_headers;
18797 i < filedata->file_header.e_shnum && section != NULL;
18798 i++, section++)
18799 {
18800 if (section->sh_type == SHT_NOTE)
18801 {
18802 if (! process_notes_at (filedata, section,
18803 (bfd_vma) section->sh_offset,
18804 (bfd_vma) section->sh_size,
18805 (bfd_vma) section->sh_addralign))
18806 res = FALSE;
18807 n++;
18808 }
18809
18810 if (( filedata->file_header.e_machine == EM_V800
18811 || filedata->file_header.e_machine == EM_V850
18812 || filedata->file_header.e_machine == EM_CYGNUS_V850)
18813 && section->sh_type == SHT_RENESAS_INFO)
18814 {
18815 if (! process_v850_notes (filedata,
18816 (bfd_vma) section->sh_offset,
18817 (bfd_vma) section->sh_size))
18818 res = FALSE;
18819 n++;
18820 }
18821 }
18822
18823 if (n == 0)
18824 /* Try processing NOTE segments instead. */
18825 return process_corefile_note_segments (filedata);
18826
18827 return res;
18828}
18829
18830static bfd_boolean
18831process_notes (Filedata * filedata)
18832{
18833 /* If we have not been asked to display the notes then do nothing. */
18834 if (! do_notes)
18835 return TRUE;
18836
18837 if (filedata->file_header.e_type != ET_CORE)
18838 return process_note_sections (filedata);
18839
18840 /* No program headers means no NOTE segment. */
18841 if (filedata->file_header.e_phnum > 0)
18842 return process_corefile_note_segments (filedata);
18843
18844 printf (_("No note segments present in the core file.\n"));
18845 return TRUE;
18846}
18847
18848static unsigned char *
18849display_public_gnu_attributes (unsigned char * start,
18850 const unsigned char * const end)
18851{
18852 printf (_(" Unknown GNU attribute: %s\n"), start);
18853
18854 start += strnlen ((char *) start, end - start);
18855 display_raw_attribute (start, end);
18856
18857 return (unsigned char *) end;
18858}
18859
18860static unsigned char *
18861display_generic_attribute (unsigned char * start,
18862 unsigned int tag,
18863 const unsigned char * const end)
18864{
18865 if (tag == 0)
18866 return (unsigned char *) end;
18867
18868 return display_tag_value (tag, start, end);
18869}
18870
18871static bfd_boolean
18872process_arch_specific (Filedata * filedata)
18873{
18874 if (! do_arch)
18875 return TRUE;
18876
18877 switch (filedata->file_header.e_machine)
18878 {
18879 case EM_ARC:
18880 case EM_ARC_COMPACT:
18881 case EM_ARC_COMPACT2:
18882 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18883 display_arc_attribute,
18884 display_generic_attribute);
18885 case EM_ARM:
18886 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18887 display_arm_attribute,
18888 display_generic_attribute);
18889
18890 case EM_MIPS:
18891 case EM_MIPS_RS3_LE:
18892 return process_mips_specific (filedata);
18893
18894 case EM_MSP430:
18895 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18896 display_msp430x_attribute,
18897 display_generic_attribute);
18898
18899 case EM_NDS32:
18900 return process_nds32_specific (filedata);
18901
18902 case EM_PPC:
18903 case EM_PPC64:
18904 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18905 display_power_gnu_attribute);
18906
18907 case EM_S390:
18908 case EM_S390_OLD:
18909 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18910 display_s390_gnu_attribute);
18911
18912 case EM_SPARC:
18913 case EM_SPARC32PLUS:
18914 case EM_SPARCV9:
18915 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18916 display_sparc_gnu_attribute);
18917
18918 case EM_TI_C6000:
18919 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18920 display_tic6x_attribute,
18921 display_generic_attribute);
18922
18923 default:
18924 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18925 display_public_gnu_attributes,
18926 display_generic_attribute);
18927 }
18928}
18929
18930static bfd_boolean
18931get_file_header (Filedata * filedata)
18932{
18933 /* Read in the identity array. */
18934 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18935 return FALSE;
18936
18937 /* Determine how to read the rest of the header. */
18938 switch (filedata->file_header.e_ident[EI_DATA])
18939 {
18940 default:
18941 case ELFDATANONE:
18942 case ELFDATA2LSB:
18943 byte_get = byte_get_little_endian;
18944 byte_put = byte_put_little_endian;
18945 break;
18946 case ELFDATA2MSB:
18947 byte_get = byte_get_big_endian;
18948 byte_put = byte_put_big_endian;
18949 break;
18950 }
18951
18952 /* For now we only support 32 bit and 64 bit ELF files. */
18953 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18954
18955 /* Read in the rest of the header. */
18956 if (is_32bit_elf)
18957 {
18958 Elf32_External_Ehdr ehdr32;
18959
18960 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18961 return FALSE;
18962
18963 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
18964 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
18965 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
18966 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
18967 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18968 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18969 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
18970 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18971 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18972 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18973 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18974 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18975 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18976 }
18977 else
18978 {
18979 Elf64_External_Ehdr ehdr64;
18980
18981 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18982 we will not be able to cope with the 64bit data found in
18983 64 ELF files. Detect this now and abort before we start
18984 overwriting things. */
18985 if (sizeof (bfd_vma) < 8)
18986 {
18987 error (_("This instance of readelf has been built without support for a\n\
1898864 bit data type and so it cannot read 64 bit ELF files.\n"));
18989 return FALSE;
18990 }
18991
18992 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18993 return FALSE;
18994
18995 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
18996 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
18997 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
18998 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
18999 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19000 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19001 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19002 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19003 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19004 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19005 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19006 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19007 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19008 }
19009
19010 if (filedata->file_header.e_shoff)
19011 {
19012 /* There may be some extensions in the first section header. Don't
19013 bomb if we can't read it. */
19014 if (is_32bit_elf)
19015 get_32bit_section_headers (filedata, TRUE);
19016 else
19017 get_64bit_section_headers (filedata, TRUE);
19018 }
19019
19020 return TRUE;
19021}
19022
19023static void
19024close_file (Filedata * filedata)
19025{
19026 if (filedata)
19027 {
19028 if (filedata->handle)
19029 fclose (filedata->handle);
19030 free (filedata);
19031 }
19032}
19033
19034void
19035close_debug_file (void * data)
19036{
19037 close_file ((Filedata *) data);
19038}
19039
19040static Filedata *
19041open_file (const char * pathname)
19042{
19043 struct stat statbuf;
19044 Filedata * filedata = NULL;
19045
19046 if (stat (pathname, & statbuf) < 0
19047 || ! S_ISREG (statbuf.st_mode))
19048 goto fail;
19049
19050 filedata = calloc (1, sizeof * filedata);
19051 if (filedata == NULL)
19052 goto fail;
19053
19054 filedata->handle = fopen (pathname, "rb");
19055 if (filedata->handle == NULL)
19056 goto fail;
19057
19058 filedata->file_size = (bfd_size_type) statbuf.st_size;
19059 filedata->file_name = pathname;
19060
19061 if (! get_file_header (filedata))
19062 goto fail;
19063
19064 if (filedata->file_header.e_shoff)
19065 {
19066 bfd_boolean res;
19067
19068 /* Read the section headers again, this time for real. */
19069 if (is_32bit_elf)
19070 res = get_32bit_section_headers (filedata, FALSE);
19071 else
19072 res = get_64bit_section_headers (filedata, FALSE);
19073
19074 if (!res)
19075 goto fail;
19076 }
19077
19078 return filedata;
19079
19080 fail:
19081 if (filedata)
19082 {
19083 if (filedata->handle)
19084 fclose (filedata->handle);
19085 free (filedata);
19086 }
19087 return NULL;
19088}
19089
19090void *
19091open_debug_file (const char * pathname)
19092{
19093 return open_file (pathname);
19094}
19095
19096/* Process one ELF object file according to the command line options.
19097 This file may actually be stored in an archive. The file is
19098 positioned at the start of the ELF object. Returns TRUE if no
19099 problems were encountered, FALSE otherwise. */
19100
19101static bfd_boolean
19102process_object (Filedata * filedata)
19103{
19104 Filedata * separates;
19105 unsigned int i;
19106 bfd_boolean res = TRUE;
19107
19108 if (! get_file_header (filedata))
19109 {
19110 error (_("%s: Failed to read file header\n"), filedata->file_name);
19111 return FALSE;
19112 }
19113
19114 /* Initialise per file variables. */
19115 for (i = ARRAY_SIZE (version_info); i--;)
19116 version_info[i] = 0;
19117
19118 for (i = ARRAY_SIZE (dynamic_info); i--;)
19119 dynamic_info[i] = 0;
19120 dynamic_info_DT_GNU_HASH = 0;
19121
19122 /* Process the file. */
19123 if (show_name)
19124 printf (_("\nFile: %s\n"), filedata->file_name);
19125
19126 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19127 Note we do this even if cmdline_dump_sects is empty because we
19128 must make sure that the dump_sets array is zeroed out before each
19129 object file is processed. */
19130 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19131 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19132
19133 if (cmdline.num_dump_sects > 0)
19134 {
19135 if (filedata->num_dump_sects == 0)
19136 /* A sneaky way of allocating the dump_sects array. */
19137 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19138
19139 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19140 memcpy (filedata->dump_sects, cmdline.dump_sects,
19141 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19142 }
19143
19144 if (! process_file_header (filedata))
19145 return FALSE;
19146
19147 if (! process_section_headers (filedata))
19148 {
19149 /* Without loaded section headers we cannot process lots of things. */
19150 do_unwind = do_version = do_dump = do_arch = FALSE;
19151
19152 if (! do_using_dynamic)
19153 do_syms = do_dyn_syms = do_reloc = FALSE;
19154 }
19155
19156 if (! process_section_groups (filedata))
19157 /* Without loaded section groups we cannot process unwind. */
19158 do_unwind = FALSE;
19159
19160 if (process_program_headers (filedata))
19161 process_dynamic_section (filedata);
19162 else
19163 res = FALSE;
19164
19165 if (! process_relocs (filedata))
19166 res = FALSE;
19167
19168 if (! process_unwind (filedata))
19169 res = FALSE;
19170
19171 if (! process_symbol_table (filedata))
19172 res = FALSE;
19173
19174 if (! process_syminfo (filedata))
19175 res = FALSE;
19176
19177 if (! process_version_sections (filedata))
19178 res = FALSE;
19179
19180 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19181 separates = load_separate_debug_file (filedata, filedata->file_name);
19182 else
19183 separates = NULL;
19184
19185 if (! process_section_contents (filedata))
19186 res = FALSE;
19187
19188 if (separates)
19189 {
19190 if (! process_section_headers (separates))
19191 res = FALSE;
19192 else if (! process_section_contents (separates))
19193 res = FALSE;
19194 }
19195
19196 if (! process_notes (filedata))
19197 res = FALSE;
19198
19199 if (! process_gnu_liblist (filedata))
19200 res = FALSE;
19201
19202 if (! process_arch_specific (filedata))
19203 res = FALSE;
19204
19205 free (filedata->program_headers);
19206 filedata->program_headers = NULL;
19207
19208 free (filedata->section_headers);
19209 filedata->section_headers = NULL;
19210
19211 free (filedata->string_table);
19212 filedata->string_table = NULL;
19213 filedata->string_table_length = 0;
19214
19215 if (dynamic_strings)
19216 {
19217 free (dynamic_strings);
19218 dynamic_strings = NULL;
19219 dynamic_strings_length = 0;
19220 }
19221
19222 if (dynamic_symbols)
19223 {
19224 free (dynamic_symbols);
19225 dynamic_symbols = NULL;
19226 num_dynamic_syms = 0;
19227 }
19228
19229 if (dynamic_syminfo)
19230 {
19231 free (dynamic_syminfo);
19232 dynamic_syminfo = NULL;
19233 }
19234
19235 if (dynamic_section)
19236 {
19237 free (dynamic_section);
19238 dynamic_section = NULL;
19239 }
19240
19241 if (section_headers_groups)
19242 {
19243 free (section_headers_groups);
19244 section_headers_groups = NULL;
19245 }
19246
19247 if (section_groups)
19248 {
19249 struct group_list * g;
19250 struct group_list * next;
19251
19252 for (i = 0; i < group_count; i++)
19253 {
19254 for (g = section_groups [i].root; g != NULL; g = next)
19255 {
19256 next = g->next;
19257 free (g);
19258 }
19259 }
19260
19261 free (section_groups);
19262 section_groups = NULL;
19263 }
19264
19265 free_debug_memory ();
19266
19267 return res;
19268}
19269
19270/* Process an ELF archive.
19271 On entry the file is positioned just after the ARMAG string.
19272 Returns TRUE upon success, FALSE otherwise. */
19273
19274static bfd_boolean
19275process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19276{
19277 struct archive_info arch;
19278 struct archive_info nested_arch;
19279 size_t got;
19280 bfd_boolean ret = TRUE;
19281
19282 show_name = TRUE;
19283
19284 /* The ARCH structure is used to hold information about this archive. */
19285 arch.file_name = NULL;
19286 arch.file = NULL;
19287 arch.index_array = NULL;
19288 arch.sym_table = NULL;
19289 arch.longnames = NULL;
19290
19291 /* The NESTED_ARCH structure is used as a single-item cache of information
19292 about a nested archive (when members of a thin archive reside within
19293 another regular archive file). */
19294 nested_arch.file_name = NULL;
19295 nested_arch.file = NULL;
19296 nested_arch.index_array = NULL;
19297 nested_arch.sym_table = NULL;
19298 nested_arch.longnames = NULL;
19299
19300 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19301 is_thin_archive, do_archive_index) != 0)
19302 {
19303 ret = FALSE;
19304 goto out;
19305 }
19306
19307 if (do_archive_index)
19308 {
19309 if (arch.sym_table == NULL)
19310 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19311 else
19312 {
19313 unsigned long i, l;
19314 unsigned long current_pos;
19315
19316 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19317 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19318
19319 current_pos = ftell (filedata->handle);
19320
19321 for (i = l = 0; i < arch.index_num; i++)
19322 {
19323 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19324 {
19325 char * member_name;
19326
19327 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19328
19329 if (member_name != NULL)
19330 {
19331 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19332
19333 if (qualified_name != NULL)
19334 {
19335 printf (_("Contents of binary %s at offset "), qualified_name);
19336 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19337 putchar ('\n');
19338 free (qualified_name);
19339 }
19340 }
19341 }
19342
19343 if (l >= arch.sym_size)
19344 {
19345 error (_("%s: end of the symbol table reached before the end of the index\n"),
19346 filedata->file_name);
19347 ret = FALSE;
19348 break;
19349 }
19350 /* PR 17531: file: 0b6630b2. */
19351 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19352 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19353 }
19354
19355 if (arch.uses_64bit_indices)
19356 l = (l + 7) & ~ 7;
19357 else
19358 l += l & 1;
19359
19360 if (l < arch.sym_size)
19361 {
19362 error (ngettext ("%s: %ld byte remains in the symbol table, "
19363 "but without corresponding entries in "
19364 "the index table\n",
19365 "%s: %ld bytes remain in the symbol table, "
19366 "but without corresponding entries in "
19367 "the index table\n",
19368 arch.sym_size - l),
19369 filedata->file_name, arch.sym_size - l);
19370 ret = FALSE;
19371 }
19372
19373 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19374 {
19375 error (_("%s: failed to seek back to start of object files in the archive\n"),
19376 filedata->file_name);
19377 ret = FALSE;
19378 goto out;
19379 }
19380 }
19381
19382 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19383 && !do_segments && !do_header && !do_dump && !do_version
19384 && !do_histogram && !do_debugging && !do_arch && !do_notes
19385 && !do_section_groups && !do_dyn_syms)
19386 {
19387 ret = TRUE; /* Archive index only. */
19388 goto out;
19389 }
19390 }
19391
19392 while (1)
19393 {
19394 char * name;
19395 size_t namelen;
19396 char * qualified_name;
19397
19398 /* Read the next archive header. */
19399 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19400 {
19401 error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19402 return FALSE;
19403 }
19404 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19405 if (got != sizeof arch.arhdr)
19406 {
19407 if (got == 0)
19408 break;
19409 error (_("%s: failed to read archive header\n"), filedata->file_name);
19410 ret = FALSE;
19411 break;
19412 }
19413 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19414 {
19415 error (_("%s: did not find a valid archive header\n"), arch.file_name);
19416 ret = FALSE;
19417 break;
19418 }
19419
19420 arch.next_arhdr_offset += sizeof arch.arhdr;
19421
19422 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19423 if (archive_file_size & 01)
19424 ++archive_file_size;
19425
19426 name = get_archive_member_name (&arch, &nested_arch);
19427 if (name == NULL)
19428 {
19429 error (_("%s: bad archive file name\n"), filedata->file_name);
19430 ret = FALSE;
19431 break;
19432 }
19433 namelen = strlen (name);
19434
19435 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19436 if (qualified_name == NULL)
19437 {
19438 error (_("%s: bad archive file name\n"), filedata->file_name);
19439 ret = FALSE;
19440 break;
19441 }
19442
19443 if (is_thin_archive && arch.nested_member_origin == 0)
19444 {
19445 /* This is a proxy for an external member of a thin archive. */
19446 Filedata * member_filedata;
19447 char * member_file_name = adjust_relative_path
19448 (filedata->file_name, name, namelen);
19449
19450 if (member_file_name == NULL)
19451 {
19452 ret = FALSE;
19453 break;
19454 }
19455
19456 member_filedata = open_file (member_file_name);
19457 if (member_filedata == NULL)
19458 {
19459 error (_("Input file '%s' is not readable.\n"), member_file_name);
19460 free (member_file_name);
19461 ret = FALSE;
19462 break;
19463 }
19464
19465 archive_file_offset = arch.nested_member_origin;
19466 member_filedata->file_name = qualified_name;
19467
19468 if (! process_object (member_filedata))
19469 ret = FALSE;
19470
19471 close_file (member_filedata);
19472 free (member_file_name);
19473 }
19474 else if (is_thin_archive)
19475 {
19476 Filedata thin_filedata;
19477
19478 memset (&thin_filedata, 0, sizeof (thin_filedata));
19479
19480 /* PR 15140: Allow for corrupt thin archives. */
19481 if (nested_arch.file == NULL)
19482 {
19483 error (_("%s: contains corrupt thin archive: %s\n"),
19484 filedata->file_name, name);
19485 ret = FALSE;
19486 break;
19487 }
19488
19489 /* This is a proxy for a member of a nested archive. */
19490 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19491
19492 /* The nested archive file will have been opened and setup by
19493 get_archive_member_name. */
19494 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19495 {
19496 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19497 ret = FALSE;
19498 break;
19499 }
19500
19501 thin_filedata.handle = nested_arch.file;
19502 thin_filedata.file_name = qualified_name;
19503
19504 if (! process_object (& thin_filedata))
19505 ret = FALSE;
19506 }
19507 else
19508 {
19509 archive_file_offset = arch.next_arhdr_offset;
19510 arch.next_arhdr_offset += archive_file_size;
19511
19512 filedata->file_name = qualified_name;
19513 if (! process_object (filedata))
19514 ret = FALSE;
19515 }
19516
19517 if (filedata->dump_sects != NULL)
19518 {
19519 free (filedata->dump_sects);
19520 filedata->dump_sects = NULL;
19521 filedata->num_dump_sects = 0;
19522 }
19523
19524 free (qualified_name);
19525 }
19526
19527 out:
19528 if (nested_arch.file != NULL)
19529 fclose (nested_arch.file);
19530 release_archive (&nested_arch);
19531 release_archive (&arch);
19532
19533 return ret;
19534}
19535
19536static bfd_boolean
19537process_file (char * file_name)
19538{
19539 Filedata * filedata = NULL;
19540 struct stat statbuf;
19541 char armag[SARMAG];
19542 bfd_boolean ret = TRUE;
19543
19544 if (stat (file_name, &statbuf) < 0)
19545 {
19546 if (errno == ENOENT)
19547 error (_("'%s': No such file\n"), file_name);
19548 else
19549 error (_("Could not locate '%s'. System error message: %s\n"),
19550 file_name, strerror (errno));
19551 return FALSE;
19552 }
19553
19554 if (! S_ISREG (statbuf.st_mode))
19555 {
19556 error (_("'%s' is not an ordinary file\n"), file_name);
19557 return FALSE;
19558 }
19559
19560 filedata = calloc (1, sizeof * filedata);
19561 if (filedata == NULL)
19562 {
19563 error (_("Out of memory allocating file data structure\n"));
19564 return FALSE;
19565 }
19566
19567 filedata->file_name = file_name;
19568 filedata->handle = fopen (file_name, "rb");
19569 if (filedata->handle == NULL)
19570 {
19571 error (_("Input file '%s' is not readable.\n"), file_name);
19572 free (filedata);
19573 return FALSE;
19574 }
19575
19576 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19577 {
19578 error (_("%s: Failed to read file's magic number\n"), file_name);
19579 fclose (filedata->handle);
19580 free (filedata);
19581 return FALSE;
19582 }
19583
19584 filedata->file_size = (bfd_size_type) statbuf.st_size;
19585
19586 if (memcmp (armag, ARMAG, SARMAG) == 0)
19587 {
19588 if (! process_archive (filedata, FALSE))
19589 ret = FALSE;
19590 }
19591 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19592 {
19593 if ( ! process_archive (filedata, TRUE))
19594 ret = FALSE;
19595 }
19596 else
19597 {
19598 if (do_archive_index)
19599 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19600 file_name);
19601
19602 rewind (filedata->handle);
19603 archive_file_size = archive_file_offset = 0;
19604
19605 if (! process_object (filedata))
19606 ret = FALSE;
19607 }
19608
19609 fclose (filedata->handle);
19610 free (filedata);
19611
19612 return ret;
19613}
19614
19615#ifdef SUPPORT_DISASSEMBLY
19616/* Needed by the i386 disassembler. For extra credit, someone could
19617 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19618 symbols. */
19619
19620void
19621print_address (unsigned int addr, FILE * outfile)
19622{
19623 fprintf (outfile,"0x%8.8x", addr);
19624}
19625
19626/* Needed by the i386 disassembler. */
19627
19628void
19629db_task_printsym (unsigned int addr)
19630{
19631 print_address (addr, stderr);
19632}
19633#endif
19634
19635int
19636main (int argc, char ** argv)
19637{
19638 int err;
19639
19640#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19641 setlocale (LC_MESSAGES, "");
19642#endif
19643#if defined (HAVE_SETLOCALE)
19644 setlocale (LC_CTYPE, "");
19645#endif
19646 bindtextdomain (PACKAGE, LOCALEDIR);
19647 textdomain (PACKAGE);
19648
19649 expandargv (&argc, &argv);
19650
19651 cmdline.file_name = "<cmdline>";
19652 parse_args (& cmdline, argc, argv);
19653
19654 if (optind < (argc - 1))
19655 show_name = TRUE;
19656 else if (optind >= argc)
19657 {
19658 warn (_("Nothing to do.\n"));
19659 usage (stderr);
19660 }
19661
19662 err = FALSE;
19663 while (optind < argc)
19664 if (! process_file (argv[optind++]))
19665 err = TRUE;
19666
19667 if (cmdline.dump_sects != NULL)
19668 free (cmdline.dump_sects);
19669
19670 return err ? EXIT_FAILURE : EXIT_SUCCESS;
19671}
GDB Binutils - Deliverables
This page took 0.144997 seconds and 4 git commands to generate.