]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
csky-opc.h: Initialize fields of last array elements
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 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 break;
3693
3694 case EM_S390:
3695 if (e_flags & EF_S390_HIGH_GPRS)
3696 strcat (buf, ", highgprs");
3697 break;
3698
3699 case EM_TI_C6000:
3700 if ((e_flags & EF_C6000_REL))
3701 strcat (buf, ", relocatable module");
3702 break;
3703
3704 case EM_MSP430:
3705 strcat (buf, _(": architecture variant: "));
3706 switch (e_flags & EF_MSP430_MACH)
3707 {
3708 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3709 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3710 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3711 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3712 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3713 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3714 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3715 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3716 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3717 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3718 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3719 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3720 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3721 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3722 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3723 default:
3724 strcat (buf, _(": unknown")); break;
3725 }
3726
3727 if (e_flags & ~ EF_MSP430_MACH)
3728 strcat (buf, _(": unknown extra flag bits also present"));
3729 }
3730 }
3731
3732 return buf;
3733}
3734
3735static const char *
3736get_osabi_name (Filedata * filedata, unsigned int osabi)
3737{
3738 static char buff[32];
3739
3740 switch (osabi)
3741 {
3742 case ELFOSABI_NONE: return "UNIX - System V";
3743 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3744 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3745 case ELFOSABI_GNU: return "UNIX - GNU";
3746 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3747 case ELFOSABI_AIX: return "UNIX - AIX";
3748 case ELFOSABI_IRIX: return "UNIX - IRIX";
3749 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3750 case ELFOSABI_TRU64: return "UNIX - TRU64";
3751 case ELFOSABI_MODESTO: return "Novell - Modesto";
3752 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3753 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3754 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3755 case ELFOSABI_AROS: return "AROS";
3756 case ELFOSABI_FENIXOS: return "FenixOS";
3757 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3758 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3759 default:
3760 if (osabi >= 64)
3761 switch (filedata->file_header.e_machine)
3762 {
3763 case EM_ARM:
3764 switch (osabi)
3765 {
3766 case ELFOSABI_ARM: return "ARM";
3767 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3768 default:
3769 break;
3770 }
3771 break;
3772
3773 case EM_MSP430:
3774 case EM_MSP430_OLD:
3775 case EM_VISIUM:
3776 switch (osabi)
3777 {
3778 case ELFOSABI_STANDALONE: return _("Standalone App");
3779 default:
3780 break;
3781 }
3782 break;
3783
3784 case EM_TI_C6000:
3785 switch (osabi)
3786 {
3787 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3788 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3789 default:
3790 break;
3791 }
3792 break;
3793
3794 default:
3795 break;
3796 }
3797 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3798 return buff;
3799 }
3800}
3801
3802static const char *
3803get_aarch64_segment_type (unsigned long type)
3804{
3805 switch (type)
3806 {
3807 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3808 default: return NULL;
3809 }
3810}
3811
3812static const char *
3813get_arm_segment_type (unsigned long type)
3814{
3815 switch (type)
3816 {
3817 case PT_ARM_EXIDX: return "EXIDX";
3818 default: return NULL;
3819 }
3820}
3821
3822static const char *
3823get_s390_segment_type (unsigned long type)
3824{
3825 switch (type)
3826 {
3827 case PT_S390_PGSTE: return "S390_PGSTE";
3828 default: return NULL;
3829 }
3830}
3831
3832static const char *
3833get_mips_segment_type (unsigned long type)
3834{
3835 switch (type)
3836 {
3837 case PT_MIPS_REGINFO: return "REGINFO";
3838 case PT_MIPS_RTPROC: return "RTPROC";
3839 case PT_MIPS_OPTIONS: return "OPTIONS";
3840 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3841 default: return NULL;
3842 }
3843}
3844
3845static const char *
3846get_parisc_segment_type (unsigned long type)
3847{
3848 switch (type)
3849 {
3850 case PT_HP_TLS: return "HP_TLS";
3851 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3852 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3853 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3854 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3855 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3856 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3857 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3858 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3859 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3860 case PT_HP_PARALLEL: return "HP_PARALLEL";
3861 case PT_HP_FASTBIND: return "HP_FASTBIND";
3862 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3863 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3864 case PT_HP_STACK: return "HP_STACK";
3865 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3866 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3867 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3868 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3869 default: return NULL;
3870 }
3871}
3872
3873static const char *
3874get_ia64_segment_type (unsigned long type)
3875{
3876 switch (type)
3877 {
3878 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3879 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3880 case PT_HP_TLS: return "HP_TLS";
3881 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3882 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3883 case PT_IA_64_HP_STACK: return "HP_STACK";
3884 default: return NULL;
3885 }
3886}
3887
3888static const char *
3889get_tic6x_segment_type (unsigned long type)
3890{
3891 switch (type)
3892 {
3893 case PT_C6000_PHATTR: return "C6000_PHATTR";
3894 default: return NULL;
3895 }
3896}
3897
3898static const char *
3899get_solaris_segment_type (unsigned long type)
3900{
3901 switch (type)
3902 {
3903 case 0x6464e550: return "PT_SUNW_UNWIND";
3904 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3905 case 0x6ffffff7: return "PT_LOSUNW";
3906 case 0x6ffffffa: return "PT_SUNWBSS";
3907 case 0x6ffffffb: return "PT_SUNWSTACK";
3908 case 0x6ffffffc: return "PT_SUNWDTRACE";
3909 case 0x6ffffffd: return "PT_SUNWCAP";
3910 case 0x6fffffff: return "PT_HISUNW";
3911 default: return NULL;
3912 }
3913}
3914
3915static const char *
3916get_segment_type (Filedata * filedata, unsigned long p_type)
3917{
3918 static char buff[32];
3919
3920 switch (p_type)
3921 {
3922 case PT_NULL: return "NULL";
3923 case PT_LOAD: return "LOAD";
3924 case PT_DYNAMIC: return "DYNAMIC";
3925 case PT_INTERP: return "INTERP";
3926 case PT_NOTE: return "NOTE";
3927 case PT_SHLIB: return "SHLIB";
3928 case PT_PHDR: return "PHDR";
3929 case PT_TLS: return "TLS";
3930 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3931 case PT_GNU_STACK: return "GNU_STACK";
3932 case PT_GNU_RELRO: return "GNU_RELRO";
3933
3934 default:
3935 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3936 {
3937 sprintf (buff, "GNU_MBIND+%#lx",
3938 p_type - PT_GNU_MBIND_LO);
3939 }
3940 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3941 {
3942 const char * result;
3943
3944 switch (filedata->file_header.e_machine)
3945 {
3946 case EM_AARCH64:
3947 result = get_aarch64_segment_type (p_type);
3948 break;
3949 case EM_ARM:
3950 result = get_arm_segment_type (p_type);
3951 break;
3952 case EM_MIPS:
3953 case EM_MIPS_RS3_LE:
3954 result = get_mips_segment_type (p_type);
3955 break;
3956 case EM_PARISC:
3957 result = get_parisc_segment_type (p_type);
3958 break;
3959 case EM_IA_64:
3960 result = get_ia64_segment_type (p_type);
3961 break;
3962 case EM_TI_C6000:
3963 result = get_tic6x_segment_type (p_type);
3964 break;
3965 case EM_S390:
3966 case EM_S390_OLD:
3967 result = get_s390_segment_type (p_type);
3968 break;
3969 default:
3970 result = NULL;
3971 break;
3972 }
3973
3974 if (result != NULL)
3975 return result;
3976
3977 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3978 }
3979 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3980 {
3981 const char * result;
3982
3983 switch (filedata->file_header.e_machine)
3984 {
3985 case EM_PARISC:
3986 result = get_parisc_segment_type (p_type);
3987 break;
3988 case EM_IA_64:
3989 result = get_ia64_segment_type (p_type);
3990 break;
3991 default:
3992 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3993 result = get_solaris_segment_type (p_type);
3994 else
3995 result = NULL;
3996 break;
3997 }
3998
3999 if (result != NULL)
4000 return result;
4001
4002 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4003 }
4004 else
4005 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4006
4007 return buff;
4008 }
4009}
4010
4011static const char *
4012get_arc_section_type_name (unsigned int sh_type)
4013{
4014 switch (sh_type)
4015 {
4016 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4017 default:
4018 break;
4019 }
4020 return NULL;
4021}
4022
4023static const char *
4024get_mips_section_type_name (unsigned int sh_type)
4025{
4026 switch (sh_type)
4027 {
4028 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4029 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4030 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4031 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4032 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4033 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4034 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4035 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4036 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4037 case SHT_MIPS_RELD: return "MIPS_RELD";
4038 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4039 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4040 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4041 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4042 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4043 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4044 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4045 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4046 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4047 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4048 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4049 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4050 case SHT_MIPS_LINE: return "MIPS_LINE";
4051 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4052 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4053 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4054 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4055 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4056 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4057 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4058 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4059 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4060 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4061 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4062 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4063 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4064 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4065 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4066 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4067 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4068 default:
4069 break;
4070 }
4071 return NULL;
4072}
4073
4074static const char *
4075get_parisc_section_type_name (unsigned int sh_type)
4076{
4077 switch (sh_type)
4078 {
4079 case SHT_PARISC_EXT: return "PARISC_EXT";
4080 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4081 case SHT_PARISC_DOC: return "PARISC_DOC";
4082 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4083 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4084 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4085 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4086 default: return NULL;
4087 }
4088}
4089
4090static const char *
4091get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4092{
4093 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4094 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4095 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4096
4097 switch (sh_type)
4098 {
4099 case SHT_IA_64_EXT: return "IA_64_EXT";
4100 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4101 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4102 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4103 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4104 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4105 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4106 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4107 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4108 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4109 default:
4110 break;
4111 }
4112 return NULL;
4113}
4114
4115static const char *
4116get_x86_64_section_type_name (unsigned int sh_type)
4117{
4118 switch (sh_type)
4119 {
4120 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4121 default: return NULL;
4122 }
4123}
4124
4125static const char *
4126get_aarch64_section_type_name (unsigned int sh_type)
4127{
4128 switch (sh_type)
4129 {
4130 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4131 default: return NULL;
4132 }
4133}
4134
4135static const char *
4136get_arm_section_type_name (unsigned int sh_type)
4137{
4138 switch (sh_type)
4139 {
4140 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4141 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4142 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4143 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4144 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4145 default: return NULL;
4146 }
4147}
4148
4149static const char *
4150get_tic6x_section_type_name (unsigned int sh_type)
4151{
4152 switch (sh_type)
4153 {
4154 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4155 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4156 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4157 case SHT_TI_ICODE: return "TI_ICODE";
4158 case SHT_TI_XREF: return "TI_XREF";
4159 case SHT_TI_HANDLER: return "TI_HANDLER";
4160 case SHT_TI_INITINFO: return "TI_INITINFO";
4161 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4162 default: return NULL;
4163 }
4164}
4165
4166static const char *
4167get_msp430x_section_type_name (unsigned int sh_type)
4168{
4169 switch (sh_type)
4170 {
4171 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4172 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4173 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4174 default: return NULL;
4175 }
4176}
4177
4178static const char *
4179get_nfp_section_type_name (unsigned int sh_type)
4180{
4181 switch (sh_type)
4182 {
4183 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4184 case SHT_NFP_INITREG: return "NFP_INITREG";
4185 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4186 default: return NULL;
4187 }
4188}
4189
4190static const char *
4191get_v850_section_type_name (unsigned int sh_type)
4192{
4193 switch (sh_type)
4194 {
4195 case SHT_V850_SCOMMON: return "V850 Small Common";
4196 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4197 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4198 case SHT_RENESAS_IOP: return "RENESAS IOP";
4199 case SHT_RENESAS_INFO: return "RENESAS INFO";
4200 default: return NULL;
4201 }
4202}
4203
4204static const char *
4205get_section_type_name (Filedata * filedata, unsigned int sh_type)
4206{
4207 static char buff[32];
4208 const char * result;
4209
4210 switch (sh_type)
4211 {
4212 case SHT_NULL: return "NULL";
4213 case SHT_PROGBITS: return "PROGBITS";
4214 case SHT_SYMTAB: return "SYMTAB";
4215 case SHT_STRTAB: return "STRTAB";
4216 case SHT_RELA: return "RELA";
4217 case SHT_HASH: return "HASH";
4218 case SHT_DYNAMIC: return "DYNAMIC";
4219 case SHT_NOTE: return "NOTE";
4220 case SHT_NOBITS: return "NOBITS";
4221 case SHT_REL: return "REL";
4222 case SHT_SHLIB: return "SHLIB";
4223 case SHT_DYNSYM: return "DYNSYM";
4224 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4225 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4226 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4227 case SHT_GNU_HASH: return "GNU_HASH";
4228 case SHT_GROUP: return "GROUP";
4229 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4230 case SHT_GNU_verdef: return "VERDEF";
4231 case SHT_GNU_verneed: return "VERNEED";
4232 case SHT_GNU_versym: return "VERSYM";
4233 case 0x6ffffff0: return "VERSYM";
4234 case 0x6ffffffc: return "VERDEF";
4235 case 0x7ffffffd: return "AUXILIARY";
4236 case 0x7fffffff: return "FILTER";
4237 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4238
4239 default:
4240 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4241 {
4242 switch (filedata->file_header.e_machine)
4243 {
4244 case EM_ARC:
4245 case EM_ARC_COMPACT:
4246 case EM_ARC_COMPACT2:
4247 result = get_arc_section_type_name (sh_type);
4248 break;
4249 case EM_MIPS:
4250 case EM_MIPS_RS3_LE:
4251 result = get_mips_section_type_name (sh_type);
4252 break;
4253 case EM_PARISC:
4254 result = get_parisc_section_type_name (sh_type);
4255 break;
4256 case EM_IA_64:
4257 result = get_ia64_section_type_name (filedata, sh_type);
4258 break;
4259 case EM_X86_64:
4260 case EM_L1OM:
4261 case EM_K1OM:
4262 result = get_x86_64_section_type_name (sh_type);
4263 break;
4264 case EM_AARCH64:
4265 result = get_aarch64_section_type_name (sh_type);
4266 break;
4267 case EM_ARM:
4268 result = get_arm_section_type_name (sh_type);
4269 break;
4270 case EM_TI_C6000:
4271 result = get_tic6x_section_type_name (sh_type);
4272 break;
4273 case EM_MSP430:
4274 result = get_msp430x_section_type_name (sh_type);
4275 break;
4276 case EM_NFP:
4277 result = get_nfp_section_type_name (sh_type);
4278 break;
4279 case EM_V800:
4280 case EM_V850:
4281 case EM_CYGNUS_V850:
4282 result = get_v850_section_type_name (sh_type);
4283 break;
4284 default:
4285 result = NULL;
4286 break;
4287 }
4288
4289 if (result != NULL)
4290 return result;
4291
4292 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4293 }
4294 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4295 {
4296 switch (filedata->file_header.e_machine)
4297 {
4298 case EM_IA_64:
4299 result = get_ia64_section_type_name (filedata, sh_type);
4300 break;
4301 default:
4302 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4303 result = get_solaris_section_type (sh_type);
4304 else
4305 {
4306 switch (sh_type)
4307 {
4308 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4309 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4310 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4311 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4312 default:
4313 result = NULL;
4314 break;
4315 }
4316 }
4317 break;
4318 }
4319
4320 if (result != NULL)
4321 return result;
4322
4323 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4324 }
4325 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4326 {
4327 switch (filedata->file_header.e_machine)
4328 {
4329 case EM_V800:
4330 case EM_V850:
4331 case EM_CYGNUS_V850:
4332 result = get_v850_section_type_name (sh_type);
4333 break;
4334 default:
4335 result = NULL;
4336 break;
4337 }
4338
4339 if (result != NULL)
4340 return result;
4341
4342 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4343 }
4344 else
4345 /* This message is probably going to be displayed in a 15
4346 character wide field, so put the hex value first. */
4347 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4348
4349 return buff;
4350 }
4351}
4352
4353#define OPTION_DEBUG_DUMP 512
4354#define OPTION_DYN_SYMS 513
4355#define OPTION_DWARF_DEPTH 514
4356#define OPTION_DWARF_START 515
4357#define OPTION_DWARF_CHECK 516
4358
4359static struct option options[] =
4360{
4361 {"all", no_argument, 0, 'a'},
4362 {"file-header", no_argument, 0, 'h'},
4363 {"program-headers", no_argument, 0, 'l'},
4364 {"headers", no_argument, 0, 'e'},
4365 {"histogram", no_argument, 0, 'I'},
4366 {"segments", no_argument, 0, 'l'},
4367 {"sections", no_argument, 0, 'S'},
4368 {"section-headers", no_argument, 0, 'S'},
4369 {"section-groups", no_argument, 0, 'g'},
4370 {"section-details", no_argument, 0, 't'},
4371 {"full-section-name",no_argument, 0, 'N'},
4372 {"symbols", no_argument, 0, 's'},
4373 {"syms", no_argument, 0, 's'},
4374 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4375 {"relocs", no_argument, 0, 'r'},
4376 {"notes", no_argument, 0, 'n'},
4377 {"dynamic", no_argument, 0, 'd'},
4378 {"arch-specific", no_argument, 0, 'A'},
4379 {"version-info", no_argument, 0, 'V'},
4380 {"use-dynamic", no_argument, 0, 'D'},
4381 {"unwind", no_argument, 0, 'u'},
4382 {"archive-index", no_argument, 0, 'c'},
4383 {"hex-dump", required_argument, 0, 'x'},
4384 {"relocated-dump", required_argument, 0, 'R'},
4385 {"string-dump", required_argument, 0, 'p'},
4386 {"decompress", no_argument, 0, 'z'},
4387#ifdef SUPPORT_DISASSEMBLY
4388 {"instruction-dump", required_argument, 0, 'i'},
4389#endif
4390 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4391
4392 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4393 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4394 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4395
4396 {"version", no_argument, 0, 'v'},
4397 {"wide", no_argument, 0, 'W'},
4398 {"help", no_argument, 0, 'H'},
4399 {0, no_argument, 0, 0}
4400};
4401
4402static void
4403usage (FILE * stream)
4404{
4405 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4406 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4407 fprintf (stream, _(" Options are:\n\
4408 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4409 -h --file-header Display the ELF file header\n\
4410 -l --program-headers Display the program headers\n\
4411 --segments An alias for --program-headers\n\
4412 -S --section-headers Display the sections' header\n\
4413 --sections An alias for --section-headers\n\
4414 -g --section-groups Display the section groups\n\
4415 -t --section-details Display the section details\n\
4416 -e --headers Equivalent to: -h -l -S\n\
4417 -s --syms Display the symbol table\n\
4418 --symbols An alias for --syms\n\
4419 --dyn-syms Display the dynamic symbol table\n\
4420 -n --notes Display the core notes (if present)\n\
4421 -r --relocs Display the relocations (if present)\n\
4422 -u --unwind Display the unwind info (if present)\n\
4423 -d --dynamic Display the dynamic section (if present)\n\
4424 -V --version-info Display the version sections (if present)\n\
4425 -A --arch-specific Display architecture specific information (if any)\n\
4426 -c --archive-index Display the symbol/file index in an archive\n\
4427 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4428 -x --hex-dump=<number|name>\n\
4429 Dump the contents of section <number|name> as bytes\n\
4430 -p --string-dump=<number|name>\n\
4431 Dump the contents of section <number|name> as strings\n\
4432 -R --relocated-dump=<number|name>\n\
4433 Dump the contents of section <number|name> as relocated bytes\n\
4434 -z --decompress Decompress section before dumping it\n\
4435 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4436 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4437 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4438 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4439 =addr,=cu_index,=links,=follow-links]\n\
4440 Display the contents of DWARF debug sections\n"));
4441 fprintf (stream, _("\
4442 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4443 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4444 or deeper\n"));
4445#ifdef SUPPORT_DISASSEMBLY
4446 fprintf (stream, _("\
4447 -i --instruction-dump=<number|name>\n\
4448 Disassemble the contents of section <number|name>\n"));
4449#endif
4450 fprintf (stream, _("\
4451 -I --histogram Display histogram of bucket list lengths\n\
4452 -W --wide Allow output width to exceed 80 characters\n\
4453 @<file> Read options from <file>\n\
4454 -H --help Display this information\n\
4455 -v --version Display the version number of readelf\n"));
4456
4457 if (REPORT_BUGS_TO[0] && stream == stdout)
4458 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4459
4460 exit (stream == stdout ? 0 : 1);
4461}
4462
4463/* Record the fact that the user wants the contents of section number
4464 SECTION to be displayed using the method(s) encoded as flags bits
4465 in TYPE. Note, TYPE can be zero if we are creating the array for
4466 the first time. */
4467
4468static void
4469request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4470{
4471 if (section >= filedata->num_dump_sects)
4472 {
4473 dump_type * new_dump_sects;
4474
4475 new_dump_sects = (dump_type *) calloc (section + 1,
4476 sizeof (* new_dump_sects));
4477
4478 if (new_dump_sects == NULL)
4479 error (_("Out of memory allocating dump request table.\n"));
4480 else
4481 {
4482 if (filedata->dump_sects)
4483 {
4484 /* Copy current flag settings. */
4485 memcpy (new_dump_sects, filedata->dump_sects,
4486 filedata->num_dump_sects * sizeof (* new_dump_sects));
4487
4488 free (filedata->dump_sects);
4489 }
4490
4491 filedata->dump_sects = new_dump_sects;
4492 filedata->num_dump_sects = section + 1;
4493 }
4494 }
4495
4496 if (filedata->dump_sects)
4497 filedata->dump_sects[section] |= type;
4498}
4499
4500/* Request a dump by section name. */
4501
4502static void
4503request_dump_byname (const char * section, dump_type type)
4504{
4505 struct dump_list_entry * new_request;
4506
4507 new_request = (struct dump_list_entry *)
4508 malloc (sizeof (struct dump_list_entry));
4509 if (!new_request)
4510 error (_("Out of memory allocating dump request table.\n"));
4511
4512 new_request->name = strdup (section);
4513 if (!new_request->name)
4514 error (_("Out of memory allocating dump request table.\n"));
4515
4516 new_request->type = type;
4517
4518 new_request->next = dump_sects_byname;
4519 dump_sects_byname = new_request;
4520}
4521
4522static inline void
4523request_dump (Filedata * filedata, dump_type type)
4524{
4525 int section;
4526 char * cp;
4527
4528 do_dump++;
4529 section = strtoul (optarg, & cp, 0);
4530
4531 if (! *cp && section >= 0)
4532 request_dump_bynumber (filedata, section, type);
4533 else
4534 request_dump_byname (optarg, type);
4535}
4536
4537static void
4538parse_args (Filedata * filedata, int argc, char ** argv)
4539{
4540 int c;
4541
4542 if (argc < 2)
4543 usage (stderr);
4544
4545 while ((c = getopt_long
4546 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4547 {
4548 switch (c)
4549 {
4550 case 0:
4551 /* Long options. */
4552 break;
4553 case 'H':
4554 usage (stdout);
4555 break;
4556
4557 case 'a':
4558 do_syms = TRUE;
4559 do_reloc = TRUE;
4560 do_unwind = TRUE;
4561 do_dynamic = TRUE;
4562 do_header = TRUE;
4563 do_sections = TRUE;
4564 do_section_groups = TRUE;
4565 do_segments = TRUE;
4566 do_version = TRUE;
4567 do_histogram = TRUE;
4568 do_arch = TRUE;
4569 do_notes = TRUE;
4570 break;
4571 case 'g':
4572 do_section_groups = TRUE;
4573 break;
4574 case 't':
4575 case 'N':
4576 do_sections = TRUE;
4577 do_section_details = TRUE;
4578 break;
4579 case 'e':
4580 do_header = TRUE;
4581 do_sections = TRUE;
4582 do_segments = TRUE;
4583 break;
4584 case 'A':
4585 do_arch = TRUE;
4586 break;
4587 case 'D':
4588 do_using_dynamic = TRUE;
4589 break;
4590 case 'r':
4591 do_reloc = TRUE;
4592 break;
4593 case 'u':
4594 do_unwind = TRUE;
4595 break;
4596 case 'h':
4597 do_header = TRUE;
4598 break;
4599 case 'l':
4600 do_segments = TRUE;
4601 break;
4602 case 's':
4603 do_syms = TRUE;
4604 break;
4605 case 'S':
4606 do_sections = TRUE;
4607 break;
4608 case 'd':
4609 do_dynamic = TRUE;
4610 break;
4611 case 'I':
4612 do_histogram = TRUE;
4613 break;
4614 case 'n':
4615 do_notes = TRUE;
4616 break;
4617 case 'c':
4618 do_archive_index = TRUE;
4619 break;
4620 case 'x':
4621 request_dump (filedata, HEX_DUMP);
4622 break;
4623 case 'p':
4624 request_dump (filedata, STRING_DUMP);
4625 break;
4626 case 'R':
4627 request_dump (filedata, RELOC_DUMP);
4628 break;
4629 case 'z':
4630 decompress_dumps = TRUE;
4631 break;
4632 case 'w':
4633 do_dump = TRUE;
4634 if (optarg == 0)
4635 {
4636 do_debugging = TRUE;
4637 dwarf_select_sections_all ();
4638 }
4639 else
4640 {
4641 do_debugging = FALSE;
4642 dwarf_select_sections_by_letters (optarg);
4643 }
4644 break;
4645 case OPTION_DEBUG_DUMP:
4646 do_dump = TRUE;
4647 if (optarg == 0)
4648 do_debugging = TRUE;
4649 else
4650 {
4651 do_debugging = FALSE;
4652 dwarf_select_sections_by_names (optarg);
4653 }
4654 break;
4655 case OPTION_DWARF_DEPTH:
4656 {
4657 char *cp;
4658
4659 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4660 }
4661 break;
4662 case OPTION_DWARF_START:
4663 {
4664 char *cp;
4665
4666 dwarf_start_die = strtoul (optarg, & cp, 0);
4667 }
4668 break;
4669 case OPTION_DWARF_CHECK:
4670 dwarf_check = TRUE;
4671 break;
4672 case OPTION_DYN_SYMS:
4673 do_dyn_syms = TRUE;
4674 break;
4675#ifdef SUPPORT_DISASSEMBLY
4676 case 'i':
4677 request_dump (filedata, DISASS_DUMP);
4678 break;
4679#endif
4680 case 'v':
4681 print_version (program_name);
4682 break;
4683 case 'V':
4684 do_version = TRUE;
4685 break;
4686 case 'W':
4687 do_wide = TRUE;
4688 break;
4689 default:
4690 /* xgettext:c-format */
4691 error (_("Invalid option '-%c'\n"), c);
4692 /* Fall through. */
4693 case '?':
4694 usage (stderr);
4695 }
4696 }
4697
4698 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4699 && !do_segments && !do_header && !do_dump && !do_version
4700 && !do_histogram && !do_debugging && !do_arch && !do_notes
4701 && !do_section_groups && !do_archive_index
4702 && !do_dyn_syms)
4703 usage (stderr);
4704}
4705
4706static const char *
4707get_elf_class (unsigned int elf_class)
4708{
4709 static char buff[32];
4710
4711 switch (elf_class)
4712 {
4713 case ELFCLASSNONE: return _("none");
4714 case ELFCLASS32: return "ELF32";
4715 case ELFCLASS64: return "ELF64";
4716 default:
4717 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4718 return buff;
4719 }
4720}
4721
4722static const char *
4723get_data_encoding (unsigned int encoding)
4724{
4725 static char buff[32];
4726
4727 switch (encoding)
4728 {
4729 case ELFDATANONE: return _("none");
4730 case ELFDATA2LSB: return _("2's complement, little endian");
4731 case ELFDATA2MSB: return _("2's complement, big endian");
4732 default:
4733 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4734 return buff;
4735 }
4736}
4737
4738/* Decode the data held in 'filedata->file_header'. */
4739
4740static bfd_boolean
4741process_file_header (Filedata * filedata)
4742{
4743 Elf_Internal_Ehdr * header = & filedata->file_header;
4744
4745 if ( header->e_ident[EI_MAG0] != ELFMAG0
4746 || header->e_ident[EI_MAG1] != ELFMAG1
4747 || header->e_ident[EI_MAG2] != ELFMAG2
4748 || header->e_ident[EI_MAG3] != ELFMAG3)
4749 {
4750 error
4751 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4752 return FALSE;
4753 }
4754
4755 init_dwarf_regnames (header->e_machine);
4756
4757 if (do_header)
4758 {
4759 unsigned i;
4760
4761 printf (_("ELF Header:\n"));
4762 printf (_(" Magic: "));
4763 for (i = 0; i < EI_NIDENT; i++)
4764 printf ("%2.2x ", header->e_ident[i]);
4765 printf ("\n");
4766 printf (_(" Class: %s\n"),
4767 get_elf_class (header->e_ident[EI_CLASS]));
4768 printf (_(" Data: %s\n"),
4769 get_data_encoding (header->e_ident[EI_DATA]));
4770 printf (_(" Version: %d%s\n"),
4771 header->e_ident[EI_VERSION],
4772 (header->e_ident[EI_VERSION] == EV_CURRENT
4773 ? _(" (current)")
4774 : (header->e_ident[EI_VERSION] != EV_NONE
4775 ? _(" <unknown>")
4776 : "")));
4777 printf (_(" OS/ABI: %s\n"),
4778 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4779 printf (_(" ABI Version: %d\n"),
4780 header->e_ident[EI_ABIVERSION]);
4781 printf (_(" Type: %s\n"),
4782 get_file_type (header->e_type));
4783 printf (_(" Machine: %s\n"),
4784 get_machine_name (header->e_machine));
4785 printf (_(" Version: 0x%lx\n"),
4786 header->e_version);
4787
4788 printf (_(" Entry point address: "));
4789 print_vma (header->e_entry, PREFIX_HEX);
4790 printf (_("\n Start of program headers: "));
4791 print_vma (header->e_phoff, DEC);
4792 printf (_(" (bytes into file)\n Start of section headers: "));
4793 print_vma (header->e_shoff, DEC);
4794 printf (_(" (bytes into file)\n"));
4795
4796 printf (_(" Flags: 0x%lx%s\n"),
4797 header->e_flags,
4798 get_machine_flags (filedata, header->e_flags, header->e_machine));
4799 printf (_(" Size of this header: %u (bytes)\n"),
4800 header->e_ehsize);
4801 printf (_(" Size of program headers: %u (bytes)\n"),
4802 header->e_phentsize);
4803 printf (_(" Number of program headers: %u"),
4804 header->e_phnum);
4805 if (filedata->section_headers != NULL
4806 && header->e_phnum == PN_XNUM
4807 && filedata->section_headers[0].sh_info != 0)
4808 {
4809 header->e_phnum = filedata->section_headers[0].sh_info;
4810 printf (" (%u)", header->e_phnum);
4811 }
4812 putc ('\n', stdout);
4813 printf (_(" Size of section headers: %u (bytes)\n"),
4814 header->e_shentsize);
4815 printf (_(" Number of section headers: %u"),
4816 header->e_shnum);
4817 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4818 {
4819 header->e_shnum = filedata->section_headers[0].sh_size;
4820 printf (" (%u)", header->e_shnum);
4821 }
4822 putc ('\n', stdout);
4823 printf (_(" Section header string table index: %u"),
4824 header->e_shstrndx);
4825 if (filedata->section_headers != NULL
4826 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4827 {
4828 header->e_shstrndx = filedata->section_headers[0].sh_link;
4829 printf (" (%u)", header->e_shstrndx);
4830 }
4831 if (header->e_shstrndx != SHN_UNDEF
4832 && header->e_shstrndx >= header->e_shnum)
4833 {
4834 header->e_shstrndx = SHN_UNDEF;
4835 printf (_(" <corrupt: out of range>"));
4836 }
4837 putc ('\n', stdout);
4838 }
4839
4840 if (filedata->section_headers != NULL)
4841 {
4842 if (header->e_phnum == PN_XNUM
4843 && filedata->section_headers[0].sh_info != 0)
4844 header->e_phnum = filedata->section_headers[0].sh_info;
4845 if (header->e_shnum == SHN_UNDEF)
4846 header->e_shnum = filedata->section_headers[0].sh_size;
4847 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4848 header->e_shstrndx = filedata->section_headers[0].sh_link;
4849 if (header->e_shstrndx >= header->e_shnum)
4850 header->e_shstrndx = SHN_UNDEF;
4851 free (filedata->section_headers);
4852 filedata->section_headers = NULL;
4853 }
4854
4855 return TRUE;
4856}
4857
4858/* Read in the program headers from FILEDATA and store them in PHEADERS.
4859 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4860
4861static bfd_boolean
4862get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4863{
4864 Elf32_External_Phdr * phdrs;
4865 Elf32_External_Phdr * external;
4866 Elf_Internal_Phdr * internal;
4867 unsigned int i;
4868 unsigned int size = filedata->file_header.e_phentsize;
4869 unsigned int num = filedata->file_header.e_phnum;
4870
4871 /* PR binutils/17531: Cope with unexpected section header sizes. */
4872 if (size == 0 || num == 0)
4873 return FALSE;
4874 if (size < sizeof * phdrs)
4875 {
4876 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4877 return FALSE;
4878 }
4879 if (size > sizeof * phdrs)
4880 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4881
4882 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4883 size, num, _("program headers"));
4884 if (phdrs == NULL)
4885 return FALSE;
4886
4887 for (i = 0, internal = pheaders, external = phdrs;
4888 i < filedata->file_header.e_phnum;
4889 i++, internal++, external++)
4890 {
4891 internal->p_type = BYTE_GET (external->p_type);
4892 internal->p_offset = BYTE_GET (external->p_offset);
4893 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4894 internal->p_paddr = BYTE_GET (external->p_paddr);
4895 internal->p_filesz = BYTE_GET (external->p_filesz);
4896 internal->p_memsz = BYTE_GET (external->p_memsz);
4897 internal->p_flags = BYTE_GET (external->p_flags);
4898 internal->p_align = BYTE_GET (external->p_align);
4899 }
4900
4901 free (phdrs);
4902 return TRUE;
4903}
4904
4905/* Read in the program headers from FILEDATA and store them in PHEADERS.
4906 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4907
4908static bfd_boolean
4909get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4910{
4911 Elf64_External_Phdr * phdrs;
4912 Elf64_External_Phdr * external;
4913 Elf_Internal_Phdr * internal;
4914 unsigned int i;
4915 unsigned int size = filedata->file_header.e_phentsize;
4916 unsigned int num = filedata->file_header.e_phnum;
4917
4918 /* PR binutils/17531: Cope with unexpected section header sizes. */
4919 if (size == 0 || num == 0)
4920 return FALSE;
4921 if (size < sizeof * phdrs)
4922 {
4923 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4924 return FALSE;
4925 }
4926 if (size > sizeof * phdrs)
4927 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4928
4929 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4930 size, num, _("program headers"));
4931 if (!phdrs)
4932 return FALSE;
4933
4934 for (i = 0, internal = pheaders, external = phdrs;
4935 i < filedata->file_header.e_phnum;
4936 i++, internal++, external++)
4937 {
4938 internal->p_type = BYTE_GET (external->p_type);
4939 internal->p_flags = BYTE_GET (external->p_flags);
4940 internal->p_offset = BYTE_GET (external->p_offset);
4941 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4942 internal->p_paddr = BYTE_GET (external->p_paddr);
4943 internal->p_filesz = BYTE_GET (external->p_filesz);
4944 internal->p_memsz = BYTE_GET (external->p_memsz);
4945 internal->p_align = BYTE_GET (external->p_align);
4946 }
4947
4948 free (phdrs);
4949 return TRUE;
4950}
4951
4952/* Returns TRUE if the program headers were read into `program_headers'. */
4953
4954static bfd_boolean
4955get_program_headers (Filedata * filedata)
4956{
4957 Elf_Internal_Phdr * phdrs;
4958
4959 /* Check cache of prior read. */
4960 if (filedata->program_headers != NULL)
4961 return TRUE;
4962
4963 /* Be kind to memory checkers by looking for
4964 e_phnum values which we know must be invalid. */
4965 if (filedata->file_header.e_phnum
4966 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4967 >= filedata->file_size)
4968 {
4969 error (_("Too many program headers - %#x - the file is not that big\n"),
4970 filedata->file_header.e_phnum);
4971 return FALSE;
4972 }
4973
4974 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4975 sizeof (Elf_Internal_Phdr));
4976 if (phdrs == NULL)
4977 {
4978 error (_("Out of memory reading %u program headers\n"),
4979 filedata->file_header.e_phnum);
4980 return FALSE;
4981 }
4982
4983 if (is_32bit_elf
4984 ? get_32bit_program_headers (filedata, phdrs)
4985 : get_64bit_program_headers (filedata, phdrs))
4986 {
4987 filedata->program_headers = phdrs;
4988 return TRUE;
4989 }
4990
4991 free (phdrs);
4992 return FALSE;
4993}
4994
4995/* Returns TRUE if the program headers were loaded. */
4996
4997static bfd_boolean
4998process_program_headers (Filedata * filedata)
4999{
5000 Elf_Internal_Phdr * segment;
5001 unsigned int i;
5002 Elf_Internal_Phdr * previous_load = NULL;
5003
5004 if (filedata->file_header.e_phnum == 0)
5005 {
5006 /* PR binutils/12467. */
5007 if (filedata->file_header.e_phoff != 0)
5008 {
5009 warn (_("possibly corrupt ELF header - it has a non-zero program"
5010 " header offset, but no program headers\n"));
5011 return FALSE;
5012 }
5013 else if (do_segments)
5014 printf (_("\nThere are no program headers in this file.\n"));
5015 return TRUE;
5016 }
5017
5018 if (do_segments && !do_header)
5019 {
5020 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5021 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5022 printf (ngettext ("There is %d program header, starting at offset %s\n",
5023 "There are %d program headers, starting at offset %s\n",
5024 filedata->file_header.e_phnum),
5025 filedata->file_header.e_phnum,
5026 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5027 }
5028
5029 if (! get_program_headers (filedata))
5030 return TRUE;
5031
5032 if (do_segments)
5033 {
5034 if (filedata->file_header.e_phnum > 1)
5035 printf (_("\nProgram Headers:\n"));
5036 else
5037 printf (_("\nProgram Headers:\n"));
5038
5039 if (is_32bit_elf)
5040 printf
5041 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5042 else if (do_wide)
5043 printf
5044 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5045 else
5046 {
5047 printf
5048 (_(" Type Offset VirtAddr PhysAddr\n"));
5049 printf
5050 (_(" FileSiz MemSiz Flags Align\n"));
5051 }
5052 }
5053
5054 dynamic_addr = 0;
5055 dynamic_size = 0;
5056
5057 for (i = 0, segment = filedata->program_headers;
5058 i < filedata->file_header.e_phnum;
5059 i++, segment++)
5060 {
5061 if (do_segments)
5062 {
5063 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5064
5065 if (is_32bit_elf)
5066 {
5067 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5068 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5069 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5070 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5071 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5072 printf ("%c%c%c ",
5073 (segment->p_flags & PF_R ? 'R' : ' '),
5074 (segment->p_flags & PF_W ? 'W' : ' '),
5075 (segment->p_flags & PF_X ? 'E' : ' '));
5076 printf ("%#lx", (unsigned long) segment->p_align);
5077 }
5078 else if (do_wide)
5079 {
5080 if ((unsigned long) segment->p_offset == segment->p_offset)
5081 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5082 else
5083 {
5084 print_vma (segment->p_offset, FULL_HEX);
5085 putchar (' ');
5086 }
5087
5088 print_vma (segment->p_vaddr, FULL_HEX);
5089 putchar (' ');
5090 print_vma (segment->p_paddr, FULL_HEX);
5091 putchar (' ');
5092
5093 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5094 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5095 else
5096 {
5097 print_vma (segment->p_filesz, FULL_HEX);
5098 putchar (' ');
5099 }
5100
5101 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5102 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5103 else
5104 {
5105 print_vma (segment->p_memsz, FULL_HEX);
5106 }
5107
5108 printf (" %c%c%c ",
5109 (segment->p_flags & PF_R ? 'R' : ' '),
5110 (segment->p_flags & PF_W ? 'W' : ' '),
5111 (segment->p_flags & PF_X ? 'E' : ' '));
5112
5113 if ((unsigned long) segment->p_align == segment->p_align)
5114 printf ("%#lx", (unsigned long) segment->p_align);
5115 else
5116 {
5117 print_vma (segment->p_align, PREFIX_HEX);
5118 }
5119 }
5120 else
5121 {
5122 print_vma (segment->p_offset, FULL_HEX);
5123 putchar (' ');
5124 print_vma (segment->p_vaddr, FULL_HEX);
5125 putchar (' ');
5126 print_vma (segment->p_paddr, FULL_HEX);
5127 printf ("\n ");
5128 print_vma (segment->p_filesz, FULL_HEX);
5129 putchar (' ');
5130 print_vma (segment->p_memsz, FULL_HEX);
5131 printf (" %c%c%c ",
5132 (segment->p_flags & PF_R ? 'R' : ' '),
5133 (segment->p_flags & PF_W ? 'W' : ' '),
5134 (segment->p_flags & PF_X ? 'E' : ' '));
5135 print_vma (segment->p_align, PREFIX_HEX);
5136 }
5137
5138 putc ('\n', stdout);
5139 }
5140
5141 switch (segment->p_type)
5142 {
5143 case PT_LOAD:
5144#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5145 required by the ELF standard, several programs, including the Linux
5146 kernel, make use of non-ordered segments. */
5147 if (previous_load
5148 && previous_load->p_vaddr > segment->p_vaddr)
5149 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5150#endif
5151 if (segment->p_memsz < segment->p_filesz)
5152 error (_("the segment's file size is larger than its memory size\n"));
5153 previous_load = segment;
5154 break;
5155
5156 case PT_PHDR:
5157 /* PR 20815 - Verify that the program header is loaded into memory. */
5158 if (i > 0 && previous_load != NULL)
5159 error (_("the PHDR segment must occur before any LOAD segment\n"));
5160 if (filedata->file_header.e_machine != EM_PARISC)
5161 {
5162 unsigned int j;
5163
5164 for (j = 1; j < filedata->file_header.e_phnum; j++)
5165 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5166 && (filedata->program_headers[j].p_vaddr
5167 + filedata->program_headers[j].p_memsz)
5168 >= (segment->p_vaddr + segment->p_filesz))
5169 break;
5170 if (j == filedata->file_header.e_phnum)
5171 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5172 }
5173 break;
5174
5175 case PT_DYNAMIC:
5176 if (dynamic_addr)
5177 error (_("more than one dynamic segment\n"));
5178
5179 /* By default, assume that the .dynamic section is the first
5180 section in the DYNAMIC segment. */
5181 dynamic_addr = segment->p_offset;
5182 dynamic_size = segment->p_filesz;
5183
5184 /* Try to locate the .dynamic section. If there is
5185 a section header table, we can easily locate it. */
5186 if (filedata->section_headers != NULL)
5187 {
5188 Elf_Internal_Shdr * sec;
5189
5190 sec = find_section (filedata, ".dynamic");
5191 if (sec == NULL || sec->sh_size == 0)
5192 {
5193 /* A corresponding .dynamic section is expected, but on
5194 IA-64/OpenVMS it is OK for it to be missing. */
5195 if (!is_ia64_vms (filedata))
5196 error (_("no .dynamic section in the dynamic segment\n"));
5197 break;
5198 }
5199
5200 if (sec->sh_type == SHT_NOBITS)
5201 {
5202 dynamic_size = 0;
5203 break;
5204 }
5205
5206 dynamic_addr = sec->sh_offset;
5207 dynamic_size = sec->sh_size;
5208
5209 if (dynamic_addr < segment->p_offset
5210 || dynamic_addr > segment->p_offset + segment->p_filesz)
5211 warn (_("the .dynamic section is not contained"
5212 " within the dynamic segment\n"));
5213 else if (dynamic_addr > segment->p_offset)
5214 warn (_("the .dynamic section is not the first section"
5215 " in the dynamic segment.\n"));
5216 }
5217
5218 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5219 segment. Check this after matching against the section headers
5220 so we don't warn on debuginfo file (which have NOBITS .dynamic
5221 sections). */
5222 if (dynamic_addr + dynamic_size >= filedata->file_size)
5223 {
5224 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5225 dynamic_addr = dynamic_size = 0;
5226 }
5227 break;
5228
5229 case PT_INTERP:
5230 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5231 SEEK_SET))
5232 error (_("Unable to find program interpreter name\n"));
5233 else
5234 {
5235 char fmt [32];
5236 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5237
5238 if (ret >= (int) sizeof (fmt) || ret < 0)
5239 error (_("Internal error: failed to create format string to display program interpreter\n"));
5240
5241 program_interpreter[0] = 0;
5242 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5243 error (_("Unable to read program interpreter name\n"));
5244
5245 if (do_segments)
5246 printf (_(" [Requesting program interpreter: %s]\n"),
5247 program_interpreter);
5248 }
5249 break;
5250 }
5251 }
5252
5253 if (do_segments
5254 && filedata->section_headers != NULL
5255 && filedata->string_table != NULL)
5256 {
5257 printf (_("\n Section to Segment mapping:\n"));
5258 printf (_(" Segment Sections...\n"));
5259
5260 for (i = 0; i < filedata->file_header.e_phnum; i++)
5261 {
5262 unsigned int j;
5263 Elf_Internal_Shdr * section;
5264
5265 segment = filedata->program_headers + i;
5266 section = filedata->section_headers + 1;
5267
5268 printf (" %2.2d ", i);
5269
5270 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5271 {
5272 if (!ELF_TBSS_SPECIAL (section, segment)
5273 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5274 printf ("%s ", printable_section_name (filedata, section));
5275 }
5276
5277 putc ('\n',stdout);
5278 }
5279 }
5280
5281 return TRUE;
5282}
5283
5284
5285/* Find the file offset corresponding to VMA by using the program headers. */
5286
5287static long
5288offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5289{
5290 Elf_Internal_Phdr * seg;
5291
5292 if (! get_program_headers (filedata))
5293 {
5294 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5295 return (long) vma;
5296 }
5297
5298 for (seg = filedata->program_headers;
5299 seg < filedata->program_headers + filedata->file_header.e_phnum;
5300 ++seg)
5301 {
5302 if (seg->p_type != PT_LOAD)
5303 continue;
5304
5305 if (vma >= (seg->p_vaddr & -seg->p_align)
5306 && vma + size <= seg->p_vaddr + seg->p_filesz)
5307 return vma - seg->p_vaddr + seg->p_offset;
5308 }
5309
5310 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5311 (unsigned long) vma);
5312 return (long) vma;
5313}
5314
5315
5316/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5317 If PROBE is true, this is just a probe and we do not generate any error
5318 messages if the load fails. */
5319
5320static bfd_boolean
5321get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5322{
5323 Elf32_External_Shdr * shdrs;
5324 Elf_Internal_Shdr * internal;
5325 unsigned int i;
5326 unsigned int size = filedata->file_header.e_shentsize;
5327 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5328
5329 /* PR binutils/17531: Cope with unexpected section header sizes. */
5330 if (size == 0 || num == 0)
5331 return FALSE;
5332 if (size < sizeof * shdrs)
5333 {
5334 if (! probe)
5335 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336 return FALSE;
5337 }
5338 if (!probe && size > sizeof * shdrs)
5339 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5340
5341 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5342 size, num,
5343 probe ? NULL : _("section headers"));
5344 if (shdrs == NULL)
5345 return FALSE;
5346
5347 free (filedata->section_headers);
5348 filedata->section_headers = (Elf_Internal_Shdr *)
5349 cmalloc (num, sizeof (Elf_Internal_Shdr));
5350 if (filedata->section_headers == NULL)
5351 {
5352 if (!probe)
5353 error (_("Out of memory reading %u section headers\n"), num);
5354 free (shdrs);
5355 return FALSE;
5356 }
5357
5358 for (i = 0, internal = filedata->section_headers;
5359 i < num;
5360 i++, internal++)
5361 {
5362 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5363 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5364 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5365 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5366 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5367 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5368 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5369 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5370 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5371 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5372 if (!probe && internal->sh_link > num)
5373 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5374 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5375 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5376 }
5377
5378 free (shdrs);
5379 return TRUE;
5380}
5381
5382/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5383
5384static bfd_boolean
5385get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5386{
5387 Elf64_External_Shdr * shdrs;
5388 Elf_Internal_Shdr * internal;
5389 unsigned int i;
5390 unsigned int size = filedata->file_header.e_shentsize;
5391 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5392
5393 /* PR binutils/17531: Cope with unexpected section header sizes. */
5394 if (size == 0 || num == 0)
5395 return FALSE;
5396
5397 if (size < sizeof * shdrs)
5398 {
5399 if (! probe)
5400 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5401 return FALSE;
5402 }
5403
5404 if (! probe && size > sizeof * shdrs)
5405 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5406
5407 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5408 filedata->file_header.e_shoff,
5409 size, num,
5410 probe ? NULL : _("section headers"));
5411 if (shdrs == NULL)
5412 return FALSE;
5413
5414 free (filedata->section_headers);
5415 filedata->section_headers = (Elf_Internal_Shdr *)
5416 cmalloc (num, sizeof (Elf_Internal_Shdr));
5417 if (filedata->section_headers == NULL)
5418 {
5419 if (! probe)
5420 error (_("Out of memory reading %u section headers\n"), num);
5421 free (shdrs);
5422 return FALSE;
5423 }
5424
5425 for (i = 0, internal = filedata->section_headers;
5426 i < num;
5427 i++, internal++)
5428 {
5429 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5430 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5431 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5432 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5433 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5434 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5435 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5436 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5437 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5438 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5439 if (!probe && internal->sh_link > num)
5440 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5441 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5442 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5443 }
5444
5445 free (shdrs);
5446 return TRUE;
5447}
5448
5449static Elf_Internal_Sym *
5450get_32bit_elf_symbols (Filedata * filedata,
5451 Elf_Internal_Shdr * section,
5452 unsigned long * num_syms_return)
5453{
5454 unsigned long number = 0;
5455 Elf32_External_Sym * esyms = NULL;
5456 Elf_External_Sym_Shndx * shndx = NULL;
5457 Elf_Internal_Sym * isyms = NULL;
5458 Elf_Internal_Sym * psym;
5459 unsigned int j;
5460 elf_section_list * entry;
5461
5462 if (section->sh_size == 0)
5463 {
5464 if (num_syms_return != NULL)
5465 * num_syms_return = 0;
5466 return NULL;
5467 }
5468
5469 /* Run some sanity checks first. */
5470 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5471 {
5472 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5473 printable_section_name (filedata, section),
5474 (unsigned long) section->sh_entsize);
5475 goto exit_point;
5476 }
5477
5478 if (section->sh_size > filedata->file_size)
5479 {
5480 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5481 printable_section_name (filedata, section),
5482 (unsigned long) section->sh_size);
5483 goto exit_point;
5484 }
5485
5486 number = section->sh_size / section->sh_entsize;
5487
5488 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5489 {
5490 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5491 (unsigned long) section->sh_size,
5492 printable_section_name (filedata, section),
5493 (unsigned long) section->sh_entsize);
5494 goto exit_point;
5495 }
5496
5497 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5498 section->sh_size, _("symbols"));
5499 if (esyms == NULL)
5500 goto exit_point;
5501
5502 shndx = NULL;
5503 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5504 {
5505 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5506 continue;
5507
5508 if (shndx != NULL)
5509 {
5510 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5511 free (shndx);
5512 }
5513
5514 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5515 entry->hdr->sh_offset,
5516 1, entry->hdr->sh_size,
5517 _("symbol table section indices"));
5518 if (shndx == NULL)
5519 goto exit_point;
5520
5521 /* PR17531: file: heap-buffer-overflow */
5522 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5523 {
5524 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5525 printable_section_name (filedata, entry->hdr),
5526 (unsigned long) entry->hdr->sh_size,
5527 (unsigned long) section->sh_size);
5528 goto exit_point;
5529 }
5530 }
5531
5532 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5533
5534 if (isyms == NULL)
5535 {
5536 error (_("Out of memory reading %lu symbols\n"),
5537 (unsigned long) number);
5538 goto exit_point;
5539 }
5540
5541 for (j = 0, psym = isyms; j < number; j++, psym++)
5542 {
5543 psym->st_name = BYTE_GET (esyms[j].st_name);
5544 psym->st_value = BYTE_GET (esyms[j].st_value);
5545 psym->st_size = BYTE_GET (esyms[j].st_size);
5546 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5547 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5548 psym->st_shndx
5549 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5550 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5551 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5552 psym->st_info = BYTE_GET (esyms[j].st_info);
5553 psym->st_other = BYTE_GET (esyms[j].st_other);
5554 }
5555
5556 exit_point:
5557 free (shndx);
5558 free (esyms);
5559
5560 if (num_syms_return != NULL)
5561 * num_syms_return = isyms == NULL ? 0 : number;
5562
5563 return isyms;
5564}
5565
5566static Elf_Internal_Sym *
5567get_64bit_elf_symbols (Filedata * filedata,
5568 Elf_Internal_Shdr * section,
5569 unsigned long * num_syms_return)
5570{
5571 unsigned long number = 0;
5572 Elf64_External_Sym * esyms = NULL;
5573 Elf_External_Sym_Shndx * shndx = NULL;
5574 Elf_Internal_Sym * isyms = NULL;
5575 Elf_Internal_Sym * psym;
5576 unsigned int j;
5577 elf_section_list * entry;
5578
5579 if (section->sh_size == 0)
5580 {
5581 if (num_syms_return != NULL)
5582 * num_syms_return = 0;
5583 return NULL;
5584 }
5585
5586 /* Run some sanity checks first. */
5587 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5588 {
5589 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5590 printable_section_name (filedata, section),
5591 (unsigned long) section->sh_entsize);
5592 goto exit_point;
5593 }
5594
5595 if (section->sh_size > filedata->file_size)
5596 {
5597 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5598 printable_section_name (filedata, section),
5599 (unsigned long) section->sh_size);
5600 goto exit_point;
5601 }
5602
5603 number = section->sh_size / section->sh_entsize;
5604
5605 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5606 {
5607 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5608 (unsigned long) section->sh_size,
5609 printable_section_name (filedata, section),
5610 (unsigned long) section->sh_entsize);
5611 goto exit_point;
5612 }
5613
5614 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5615 section->sh_size, _("symbols"));
5616 if (!esyms)
5617 goto exit_point;
5618
5619 shndx = NULL;
5620 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5621 {
5622 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5623 continue;
5624
5625 if (shndx != NULL)
5626 {
5627 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5628 free (shndx);
5629 }
5630
5631 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5632 entry->hdr->sh_offset,
5633 1, entry->hdr->sh_size,
5634 _("symbol table section indices"));
5635 if (shndx == NULL)
5636 goto exit_point;
5637
5638 /* PR17531: file: heap-buffer-overflow */
5639 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5640 {
5641 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5642 printable_section_name (filedata, entry->hdr),
5643 (unsigned long) entry->hdr->sh_size,
5644 (unsigned long) section->sh_size);
5645 goto exit_point;
5646 }
5647 }
5648
5649 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5650
5651 if (isyms == NULL)
5652 {
5653 error (_("Out of memory reading %lu symbols\n"),
5654 (unsigned long) number);
5655 goto exit_point;
5656 }
5657
5658 for (j = 0, psym = isyms; j < number; j++, psym++)
5659 {
5660 psym->st_name = BYTE_GET (esyms[j].st_name);
5661 psym->st_info = BYTE_GET (esyms[j].st_info);
5662 psym->st_other = BYTE_GET (esyms[j].st_other);
5663 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5664
5665 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5666 psym->st_shndx
5667 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5668 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5669 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5670
5671 psym->st_value = BYTE_GET (esyms[j].st_value);
5672 psym->st_size = BYTE_GET (esyms[j].st_size);
5673 }
5674
5675 exit_point:
5676 free (shndx);
5677 free (esyms);
5678
5679 if (num_syms_return != NULL)
5680 * num_syms_return = isyms == NULL ? 0 : number;
5681
5682 return isyms;
5683}
5684
5685static const char *
5686get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5687{
5688 static char buff[1024];
5689 char * p = buff;
5690 unsigned int field_size = is_32bit_elf ? 8 : 16;
5691 signed int sindex;
5692 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5693 bfd_vma os_flags = 0;
5694 bfd_vma proc_flags = 0;
5695 bfd_vma unknown_flags = 0;
5696 static const struct
5697 {
5698 const char * str;
5699 unsigned int len;
5700 }
5701 flags [] =
5702 {
5703 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5704 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5705 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5706 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5707 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5708 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5709 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5710 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5711 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5712 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5713 /* IA-64 specific. */
5714 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5715 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5716 /* IA-64 OpenVMS specific. */
5717 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5718 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5719 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5720 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5721 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5722 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5723 /* Generic. */
5724 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5725 /* SPARC specific. */
5726 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5727 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5728 /* ARM specific. */
5729 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5730 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5731 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5732 /* GNU specific. */
5733 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5734 /* VLE specific. */
5735 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5736 };
5737
5738 if (do_section_details)
5739 {
5740 sprintf (buff, "[%*.*lx]: ",
5741 field_size, field_size, (unsigned long) sh_flags);
5742 p += field_size + 4;
5743 }
5744
5745 while (sh_flags)
5746 {
5747 bfd_vma flag;
5748
5749 flag = sh_flags & - sh_flags;
5750 sh_flags &= ~ flag;
5751
5752 if (do_section_details)
5753 {
5754 switch (flag)
5755 {
5756 case SHF_WRITE: sindex = 0; break;
5757 case SHF_ALLOC: sindex = 1; break;
5758 case SHF_EXECINSTR: sindex = 2; break;
5759 case SHF_MERGE: sindex = 3; break;
5760 case SHF_STRINGS: sindex = 4; break;
5761 case SHF_INFO_LINK: sindex = 5; break;
5762 case SHF_LINK_ORDER: sindex = 6; break;
5763 case SHF_OS_NONCONFORMING: sindex = 7; break;
5764 case SHF_GROUP: sindex = 8; break;
5765 case SHF_TLS: sindex = 9; break;
5766 case SHF_EXCLUDE: sindex = 18; break;
5767 case SHF_COMPRESSED: sindex = 20; break;
5768 case SHF_GNU_MBIND: sindex = 24; break;
5769
5770 default:
5771 sindex = -1;
5772 switch (filedata->file_header.e_machine)
5773 {
5774 case EM_IA_64:
5775 if (flag == SHF_IA_64_SHORT)
5776 sindex = 10;
5777 else if (flag == SHF_IA_64_NORECOV)
5778 sindex = 11;
5779#ifdef BFD64
5780 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5781 switch (flag)
5782 {
5783 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5784 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5785 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5786 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5787 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5788 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5789 default: break;
5790 }
5791#endif
5792 break;
5793
5794 case EM_386:
5795 case EM_IAMCU:
5796 case EM_X86_64:
5797 case EM_L1OM:
5798 case EM_K1OM:
5799 case EM_OLD_SPARCV9:
5800 case EM_SPARC32PLUS:
5801 case EM_SPARCV9:
5802 case EM_SPARC:
5803 if (flag == SHF_ORDERED)
5804 sindex = 19;
5805 break;
5806
5807 case EM_ARM:
5808 switch (flag)
5809 {
5810 case SHF_ENTRYSECT: sindex = 21; break;
5811 case SHF_ARM_PURECODE: sindex = 22; break;
5812 case SHF_COMDEF: sindex = 23; break;
5813 default: break;
5814 }
5815 break;
5816 case EM_PPC:
5817 if (flag == SHF_PPC_VLE)
5818 sindex = 25;
5819 break;
5820
5821 default:
5822 break;
5823 }
5824 }
5825
5826 if (sindex != -1)
5827 {
5828 if (p != buff + field_size + 4)
5829 {
5830 if (size < (10 + 2))
5831 {
5832 warn (_("Internal error: not enough buffer room for section flag info"));
5833 return _("<unknown>");
5834 }
5835 size -= 2;
5836 *p++ = ',';
5837 *p++ = ' ';
5838 }
5839
5840 size -= flags [sindex].len;
5841 p = stpcpy (p, flags [sindex].str);
5842 }
5843 else if (flag & SHF_MASKOS)
5844 os_flags |= flag;
5845 else if (flag & SHF_MASKPROC)
5846 proc_flags |= flag;
5847 else
5848 unknown_flags |= flag;
5849 }
5850 else
5851 {
5852 switch (flag)
5853 {
5854 case SHF_WRITE: *p = 'W'; break;
5855 case SHF_ALLOC: *p = 'A'; break;
5856 case SHF_EXECINSTR: *p = 'X'; break;
5857 case SHF_MERGE: *p = 'M'; break;
5858 case SHF_STRINGS: *p = 'S'; break;
5859 case SHF_INFO_LINK: *p = 'I'; break;
5860 case SHF_LINK_ORDER: *p = 'L'; break;
5861 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5862 case SHF_GROUP: *p = 'G'; break;
5863 case SHF_TLS: *p = 'T'; break;
5864 case SHF_EXCLUDE: *p = 'E'; break;
5865 case SHF_COMPRESSED: *p = 'C'; break;
5866 case SHF_GNU_MBIND: *p = 'D'; break;
5867
5868 default:
5869 if ((filedata->file_header.e_machine == EM_X86_64
5870 || filedata->file_header.e_machine == EM_L1OM
5871 || filedata->file_header.e_machine == EM_K1OM)
5872 && flag == SHF_X86_64_LARGE)
5873 *p = 'l';
5874 else if (filedata->file_header.e_machine == EM_ARM
5875 && flag == SHF_ARM_PURECODE)
5876 *p = 'y';
5877 else if (filedata->file_header.e_machine == EM_PPC
5878 && flag == SHF_PPC_VLE)
5879 *p = 'v';
5880 else if (flag & SHF_MASKOS)
5881 {
5882 *p = 'o';
5883 sh_flags &= ~ SHF_MASKOS;
5884 }
5885 else if (flag & SHF_MASKPROC)
5886 {
5887 *p = 'p';
5888 sh_flags &= ~ SHF_MASKPROC;
5889 }
5890 else
5891 *p = 'x';
5892 break;
5893 }
5894 p++;
5895 }
5896 }
5897
5898 if (do_section_details)
5899 {
5900 if (os_flags)
5901 {
5902 size -= 5 + field_size;
5903 if (p != buff + field_size + 4)
5904 {
5905 if (size < (2 + 1))
5906 {
5907 warn (_("Internal error: not enough buffer room for section flag info"));
5908 return _("<unknown>");
5909 }
5910 size -= 2;
5911 *p++ = ',';
5912 *p++ = ' ';
5913 }
5914 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5915 (unsigned long) os_flags);
5916 p += 5 + field_size;
5917 }
5918 if (proc_flags)
5919 {
5920 size -= 7 + field_size;
5921 if (p != buff + field_size + 4)
5922 {
5923 if (size < (2 + 1))
5924 {
5925 warn (_("Internal error: not enough buffer room for section flag info"));
5926 return _("<unknown>");
5927 }
5928 size -= 2;
5929 *p++ = ',';
5930 *p++ = ' ';
5931 }
5932 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5933 (unsigned long) proc_flags);
5934 p += 7 + field_size;
5935 }
5936 if (unknown_flags)
5937 {
5938 size -= 10 + field_size;
5939 if (p != buff + field_size + 4)
5940 {
5941 if (size < (2 + 1))
5942 {
5943 warn (_("Internal error: not enough buffer room for section flag info"));
5944 return _("<unknown>");
5945 }
5946 size -= 2;
5947 *p++ = ',';
5948 *p++ = ' ';
5949 }
5950 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5951 (unsigned long) unknown_flags);
5952 p += 10 + field_size;
5953 }
5954 }
5955
5956 *p = '\0';
5957 return buff;
5958}
5959
5960static unsigned int
5961get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5962{
5963 if (is_32bit_elf)
5964 {
5965 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5966
5967 if (size < sizeof (* echdr))
5968 {
5969 error (_("Compressed section is too small even for a compression header\n"));
5970 return 0;
5971 }
5972
5973 chdr->ch_type = BYTE_GET (echdr->ch_type);
5974 chdr->ch_size = BYTE_GET (echdr->ch_size);
5975 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5976 return sizeof (*echdr);
5977 }
5978 else
5979 {
5980 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5981
5982 if (size < sizeof (* echdr))
5983 {
5984 error (_("Compressed section is too small even for a compression header\n"));
5985 return 0;
5986 }
5987
5988 chdr->ch_type = BYTE_GET (echdr->ch_type);
5989 chdr->ch_size = BYTE_GET (echdr->ch_size);
5990 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5991 return sizeof (*echdr);
5992 }
5993}
5994
5995static bfd_boolean
5996process_section_headers (Filedata * filedata)
5997{
5998 Elf_Internal_Shdr * section;
5999 unsigned int i;
6000
6001 filedata->section_headers = NULL;
6002
6003 if (filedata->file_header.e_shnum == 0)
6004 {
6005 /* PR binutils/12467. */
6006 if (filedata->file_header.e_shoff != 0)
6007 {
6008 warn (_("possibly corrupt ELF file header - it has a non-zero"
6009 " section header offset, but no section headers\n"));
6010 return FALSE;
6011 }
6012 else if (do_sections)
6013 printf (_("\nThere are no sections in this file.\n"));
6014
6015 return TRUE;
6016 }
6017
6018 if (do_sections && !do_header)
6019 printf (ngettext ("There is %d section header, "
6020 "starting at offset 0x%lx:\n",
6021 "There are %d section headers, "
6022 "starting at offset 0x%lx:\n",
6023 filedata->file_header.e_shnum),
6024 filedata->file_header.e_shnum,
6025 (unsigned long) filedata->file_header.e_shoff);
6026
6027 if (is_32bit_elf)
6028 {
6029 if (! get_32bit_section_headers (filedata, FALSE))
6030 return FALSE;
6031 }
6032 else
6033 {
6034 if (! get_64bit_section_headers (filedata, FALSE))
6035 return FALSE;
6036 }
6037
6038 /* Read in the string table, so that we have names to display. */
6039 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6040 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6041 {
6042 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6043
6044 if (section->sh_size != 0)
6045 {
6046 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6047 1, section->sh_size,
6048 _("string table"));
6049
6050 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6051 }
6052 }
6053
6054 /* Scan the sections for the dynamic symbol table
6055 and dynamic string table and debug sections. */
6056 dynamic_symbols = NULL;
6057 dynamic_strings = NULL;
6058 dynamic_syminfo = NULL;
6059 symtab_shndx_list = NULL;
6060
6061 eh_addr_size = is_32bit_elf ? 4 : 8;
6062 switch (filedata->file_header.e_machine)
6063 {
6064 case EM_MIPS:
6065 case EM_MIPS_RS3_LE:
6066 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6067 FDE addresses. However, the ABI also has a semi-official ILP32
6068 variant for which the normal FDE address size rules apply.
6069
6070 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6071 section, where XX is the size of longs in bits. Unfortunately,
6072 earlier compilers provided no way of distinguishing ILP32 objects
6073 from LP64 objects, so if there's any doubt, we should assume that
6074 the official LP64 form is being used. */
6075 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6076 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6077 eh_addr_size = 8;
6078 break;
6079
6080 case EM_H8_300:
6081 case EM_H8_300H:
6082 switch (filedata->file_header.e_flags & EF_H8_MACH)
6083 {
6084 case E_H8_MACH_H8300:
6085 case E_H8_MACH_H8300HN:
6086 case E_H8_MACH_H8300SN:
6087 case E_H8_MACH_H8300SXN:
6088 eh_addr_size = 2;
6089 break;
6090 case E_H8_MACH_H8300H:
6091 case E_H8_MACH_H8300S:
6092 case E_H8_MACH_H8300SX:
6093 eh_addr_size = 4;
6094 break;
6095 }
6096 break;
6097
6098 case EM_M32C_OLD:
6099 case EM_M32C:
6100 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6101 {
6102 case EF_M32C_CPU_M16C:
6103 eh_addr_size = 2;
6104 break;
6105 }
6106 break;
6107 }
6108
6109#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6110 do \
6111 { \
6112 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6113 if (section->sh_entsize != expected_entsize) \
6114 { \
6115 char buf[40]; \
6116 sprintf_vma (buf, section->sh_entsize); \
6117 /* Note: coded this way so that there is a single string for \
6118 translation. */ \
6119 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6120 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6121 (unsigned) expected_entsize); \
6122 section->sh_entsize = expected_entsize; \
6123 } \
6124 } \
6125 while (0)
6126
6127#define CHECK_ENTSIZE(section, i, type) \
6128 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6129 sizeof (Elf64_External_##type))
6130
6131 for (i = 0, section = filedata->section_headers;
6132 i < filedata->file_header.e_shnum;
6133 i++, section++)
6134 {
6135 char * name = SECTION_NAME (section);
6136
6137 if (section->sh_type == SHT_DYNSYM)
6138 {
6139 if (dynamic_symbols != NULL)
6140 {
6141 error (_("File contains multiple dynamic symbol tables\n"));
6142 continue;
6143 }
6144
6145 CHECK_ENTSIZE (section, i, Sym);
6146 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6147 }
6148 else if (section->sh_type == SHT_STRTAB
6149 && streq (name, ".dynstr"))
6150 {
6151 if (dynamic_strings != NULL)
6152 {
6153 error (_("File contains multiple dynamic string tables\n"));
6154 continue;
6155 }
6156
6157 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6158 1, section->sh_size,
6159 _("dynamic strings"));
6160 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6161 }
6162 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6163 {
6164 elf_section_list * entry = xmalloc (sizeof * entry);
6165
6166 entry->hdr = section;
6167 entry->next = symtab_shndx_list;
6168 symtab_shndx_list = entry;
6169 }
6170 else if (section->sh_type == SHT_SYMTAB)
6171 CHECK_ENTSIZE (section, i, Sym);
6172 else if (section->sh_type == SHT_GROUP)
6173 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6174 else if (section->sh_type == SHT_REL)
6175 CHECK_ENTSIZE (section, i, Rel);
6176 else if (section->sh_type == SHT_RELA)
6177 CHECK_ENTSIZE (section, i, Rela);
6178 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6179 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6180 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6181 || do_debug_str || do_debug_loc || do_debug_ranges
6182 || do_debug_addr || do_debug_cu_index || do_debug_links)
6183 && (const_strneq (name, ".debug_")
6184 || const_strneq (name, ".zdebug_")))
6185 {
6186 if (name[1] == 'z')
6187 name += sizeof (".zdebug_") - 1;
6188 else
6189 name += sizeof (".debug_") - 1;
6190
6191 if (do_debugging
6192 || (do_debug_info && const_strneq (name, "info"))
6193 || (do_debug_info && const_strneq (name, "types"))
6194 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6195 || (do_debug_lines && strcmp (name, "line") == 0)
6196 || (do_debug_lines && const_strneq (name, "line."))
6197 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6198 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6199 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6200 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6201 || (do_debug_aranges && const_strneq (name, "aranges"))
6202 || (do_debug_ranges && const_strneq (name, "ranges"))
6203 || (do_debug_ranges && const_strneq (name, "rnglists"))
6204 || (do_debug_frames && const_strneq (name, "frame"))
6205 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6206 || (do_debug_macinfo && const_strneq (name, "macro"))
6207 || (do_debug_str && const_strneq (name, "str"))
6208 || (do_debug_loc && const_strneq (name, "loc"))
6209 || (do_debug_loc && const_strneq (name, "loclists"))
6210 || (do_debug_addr && const_strneq (name, "addr"))
6211 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6212 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6213 )
6214 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6215 }
6216 /* Linkonce section to be combined with .debug_info at link time. */
6217 else if ((do_debugging || do_debug_info)
6218 && const_strneq (name, ".gnu.linkonce.wi."))
6219 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220 else if (do_debug_frames && streq (name, ".eh_frame"))
6221 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6222 else if (do_gdb_index && (streq (name, ".gdb_index")
6223 || streq (name, ".debug_names")))
6224 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6225 /* Trace sections for Itanium VMS. */
6226 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6227 || do_trace_aranges)
6228 && const_strneq (name, ".trace_"))
6229 {
6230 name += sizeof (".trace_") - 1;
6231
6232 if (do_debugging
6233 || (do_trace_info && streq (name, "info"))
6234 || (do_trace_abbrevs && streq (name, "abbrev"))
6235 || (do_trace_aranges && streq (name, "aranges"))
6236 )
6237 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6238 }
6239 else if ((do_debugging || do_debug_links)
6240 && (const_strneq (name, ".gnu_debuglink")
6241 || const_strneq (name, ".gnu_debugaltlink")))
6242 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6243 }
6244
6245 if (! do_sections)
6246 return TRUE;
6247
6248 if (filedata->file_header.e_shnum > 1)
6249 printf (_("\nSection Headers:\n"));
6250 else
6251 printf (_("\nSection Header:\n"));
6252
6253 if (is_32bit_elf)
6254 {
6255 if (do_section_details)
6256 {
6257 printf (_(" [Nr] Name\n"));
6258 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6259 }
6260 else
6261 printf
6262 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6263 }
6264 else if (do_wide)
6265 {
6266 if (do_section_details)
6267 {
6268 printf (_(" [Nr] Name\n"));
6269 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6270 }
6271 else
6272 printf
6273 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6274 }
6275 else
6276 {
6277 if (do_section_details)
6278 {
6279 printf (_(" [Nr] Name\n"));
6280 printf (_(" Type Address Offset Link\n"));
6281 printf (_(" Size EntSize Info Align\n"));
6282 }
6283 else
6284 {
6285 printf (_(" [Nr] Name Type Address Offset\n"));
6286 printf (_(" Size EntSize Flags Link Info Align\n"));
6287 }
6288 }
6289
6290 if (do_section_details)
6291 printf (_(" Flags\n"));
6292
6293 for (i = 0, section = filedata->section_headers;
6294 i < filedata->file_header.e_shnum;
6295 i++, section++)
6296 {
6297 /* Run some sanity checks on the section header. */
6298
6299 /* Check the sh_link field. */
6300 switch (section->sh_type)
6301 {
6302 case SHT_SYMTAB_SHNDX:
6303 case SHT_GROUP:
6304 case SHT_HASH:
6305 case SHT_GNU_HASH:
6306 case SHT_GNU_versym:
6307 case SHT_REL:
6308 case SHT_RELA:
6309 if (section->sh_link < 1
6310 || section->sh_link >= filedata->file_header.e_shnum
6311 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6312 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6313 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6314 i, section->sh_link);
6315 break;
6316
6317 case SHT_DYNAMIC:
6318 case SHT_SYMTAB:
6319 case SHT_DYNSYM:
6320 case SHT_GNU_verneed:
6321 case SHT_GNU_verdef:
6322 case SHT_GNU_LIBLIST:
6323 if (section->sh_link < 1
6324 || section->sh_link >= filedata->file_header.e_shnum
6325 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6326 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6327 i, section->sh_link);
6328 break;
6329
6330 case SHT_INIT_ARRAY:
6331 case SHT_FINI_ARRAY:
6332 case SHT_PREINIT_ARRAY:
6333 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6334 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6335 i, section->sh_link);
6336 break;
6337
6338 default:
6339 /* FIXME: Add support for target specific section types. */
6340#if 0 /* Currently we do not check other section types as there are too
6341 many special cases. Stab sections for example have a type
6342 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6343 section. */
6344 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6345 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6346 i, section->sh_link);
6347#endif
6348 break;
6349 }
6350
6351 /* Check the sh_info field. */
6352 switch (section->sh_type)
6353 {
6354 case SHT_REL:
6355 case SHT_RELA:
6356 if (section->sh_info < 1
6357 || section->sh_info >= filedata->file_header.e_shnum
6358 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6359 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6360 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6361 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6362 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6363 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6364 /* FIXME: Are other section types valid ? */
6365 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6366 {
6367 if (section->sh_info == 0
6368 && (filedata->file_header.e_type == ET_EXEC
6369 || filedata->file_header.e_type == ET_DYN
6370 /* These next two tests may be redundant, but
6371 they have been left in for paranoia's sake. */
6372 || streq (SECTION_NAME (section), ".rel.dyn")
6373 || streq (SECTION_NAME (section), ".rela.dyn")))
6374 /* Dynamic relocations apply to segments, not sections, so
6375 they do not need an sh_info value. */
6376 ;
6377 else
6378 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6379 i, section->sh_info);
6380 }
6381 break;
6382
6383 case SHT_DYNAMIC:
6384 case SHT_HASH:
6385 case SHT_SYMTAB_SHNDX:
6386 case SHT_INIT_ARRAY:
6387 case SHT_FINI_ARRAY:
6388 case SHT_PREINIT_ARRAY:
6389 if (section->sh_info != 0)
6390 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6391 i, section->sh_info);
6392 break;
6393
6394 case SHT_GROUP:
6395 case SHT_SYMTAB:
6396 case SHT_DYNSYM:
6397 /* A symbol index - we assume that it is valid. */
6398 break;
6399
6400 default:
6401 /* FIXME: Add support for target specific section types. */
6402 if (section->sh_type == SHT_NOBITS)
6403 /* NOBITS section headers with non-zero sh_info fields can be
6404 created when a binary is stripped of everything but its debug
6405 information. The stripped sections have their headers
6406 preserved but their types set to SHT_NOBITS. So do not check
6407 this type of section. */
6408 ;
6409 else if (section->sh_flags & SHF_INFO_LINK)
6410 {
6411 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6412 warn (_("[%2u]: Expected link to another section in info field"), i);
6413 }
6414 else if (section->sh_type < SHT_LOOS
6415 && (section->sh_flags & SHF_GNU_MBIND) == 0
6416 && section->sh_info != 0)
6417 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6418 i, section->sh_info);
6419 break;
6420 }
6421
6422 /* Check the sh_size field. */
6423 if (section->sh_size > filedata->file_size
6424 && section->sh_type != SHT_NOBITS
6425 && section->sh_type != SHT_NULL
6426 && section->sh_type < SHT_LOOS)
6427 warn (_("Size of section %u is larger than the entire file!\n"), i);
6428
6429 printf (" [%2u] ", i);
6430 if (do_section_details)
6431 printf ("%s\n ", printable_section_name (filedata, section));
6432 else
6433 print_symbol (-17, SECTION_NAME (section));
6434
6435 printf (do_wide ? " %-15s " : " %-15.15s ",
6436 get_section_type_name (filedata, section->sh_type));
6437
6438 if (is_32bit_elf)
6439 {
6440 const char * link_too_big = NULL;
6441
6442 print_vma (section->sh_addr, LONG_HEX);
6443
6444 printf ( " %6.6lx %6.6lx %2.2lx",
6445 (unsigned long) section->sh_offset,
6446 (unsigned long) section->sh_size,
6447 (unsigned long) section->sh_entsize);
6448
6449 if (do_section_details)
6450 fputs (" ", stdout);
6451 else
6452 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6453
6454 if (section->sh_link >= filedata->file_header.e_shnum)
6455 {
6456 link_too_big = "";
6457 /* The sh_link value is out of range. Normally this indicates
6458 an error but it can have special values in Solaris binaries. */
6459 switch (filedata->file_header.e_machine)
6460 {
6461 case EM_386:
6462 case EM_IAMCU:
6463 case EM_X86_64:
6464 case EM_L1OM:
6465 case EM_K1OM:
6466 case EM_OLD_SPARCV9:
6467 case EM_SPARC32PLUS:
6468 case EM_SPARCV9:
6469 case EM_SPARC:
6470 if (section->sh_link == (SHN_BEFORE & 0xffff))
6471 link_too_big = "BEFORE";
6472 else if (section->sh_link == (SHN_AFTER & 0xffff))
6473 link_too_big = "AFTER";
6474 break;
6475 default:
6476 break;
6477 }
6478 }
6479
6480 if (do_section_details)
6481 {
6482 if (link_too_big != NULL && * link_too_big)
6483 printf ("<%s> ", link_too_big);
6484 else
6485 printf ("%2u ", section->sh_link);
6486 printf ("%3u %2lu\n", section->sh_info,
6487 (unsigned long) section->sh_addralign);
6488 }
6489 else
6490 printf ("%2u %3u %2lu\n",
6491 section->sh_link,
6492 section->sh_info,
6493 (unsigned long) section->sh_addralign);
6494
6495 if (link_too_big && ! * link_too_big)
6496 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6497 i, section->sh_link);
6498 }
6499 else if (do_wide)
6500 {
6501 print_vma (section->sh_addr, LONG_HEX);
6502
6503 if ((long) section->sh_offset == section->sh_offset)
6504 printf (" %6.6lx", (unsigned long) section->sh_offset);
6505 else
6506 {
6507 putchar (' ');
6508 print_vma (section->sh_offset, LONG_HEX);
6509 }
6510
6511 if ((unsigned long) section->sh_size == section->sh_size)
6512 printf (" %6.6lx", (unsigned long) section->sh_size);
6513 else
6514 {
6515 putchar (' ');
6516 print_vma (section->sh_size, LONG_HEX);
6517 }
6518
6519 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6520 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6521 else
6522 {
6523 putchar (' ');
6524 print_vma (section->sh_entsize, LONG_HEX);
6525 }
6526
6527 if (do_section_details)
6528 fputs (" ", stdout);
6529 else
6530 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6531
6532 printf ("%2u %3u ", section->sh_link, section->sh_info);
6533
6534 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6535 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6536 else
6537 {
6538 print_vma (section->sh_addralign, DEC);
6539 putchar ('\n');
6540 }
6541 }
6542 else if (do_section_details)
6543 {
6544 putchar (' ');
6545 print_vma (section->sh_addr, LONG_HEX);
6546 if ((long) section->sh_offset == section->sh_offset)
6547 printf (" %16.16lx", (unsigned long) section->sh_offset);
6548 else
6549 {
6550 printf (" ");
6551 print_vma (section->sh_offset, LONG_HEX);
6552 }
6553 printf (" %u\n ", section->sh_link);
6554 print_vma (section->sh_size, LONG_HEX);
6555 putchar (' ');
6556 print_vma (section->sh_entsize, LONG_HEX);
6557
6558 printf (" %-16u %lu\n",
6559 section->sh_info,
6560 (unsigned long) section->sh_addralign);
6561 }
6562 else
6563 {
6564 putchar (' ');
6565 print_vma (section->sh_addr, LONG_HEX);
6566 if ((long) section->sh_offset == section->sh_offset)
6567 printf (" %8.8lx", (unsigned long) section->sh_offset);
6568 else
6569 {
6570 printf (" ");
6571 print_vma (section->sh_offset, LONG_HEX);
6572 }
6573 printf ("\n ");
6574 print_vma (section->sh_size, LONG_HEX);
6575 printf (" ");
6576 print_vma (section->sh_entsize, LONG_HEX);
6577
6578 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6579
6580 printf (" %2u %3u %lu\n",
6581 section->sh_link,
6582 section->sh_info,
6583 (unsigned long) section->sh_addralign);
6584 }
6585
6586 if (do_section_details)
6587 {
6588 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6589 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6590 {
6591 /* Minimum section size is 12 bytes for 32-bit compression
6592 header + 12 bytes for compressed data header. */
6593 unsigned char buf[24];
6594
6595 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6596 if (get_data (&buf, filedata, section->sh_offset, 1,
6597 sizeof (buf), _("compression header")))
6598 {
6599 Elf_Internal_Chdr chdr;
6600
6601 (void) get_compression_header (&chdr, buf, sizeof (buf));
6602
6603 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6604 printf (" ZLIB, ");
6605 else
6606 printf (_(" [<unknown>: 0x%x], "),
6607 chdr.ch_type);
6608 print_vma (chdr.ch_size, LONG_HEX);
6609 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6610 }
6611 }
6612 }
6613 }
6614
6615 if (!do_section_details)
6616 {
6617 /* The ordering of the letters shown here matches the ordering of the
6618 corresponding SHF_xxx values, and hence the order in which these
6619 letters will be displayed to the user. */
6620 printf (_("Key to Flags:\n\
6621 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6622 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6623 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6624 if (filedata->file_header.e_machine == EM_X86_64
6625 || filedata->file_header.e_machine == EM_L1OM
6626 || filedata->file_header.e_machine == EM_K1OM)
6627 printf (_("l (large), "));
6628 else if (filedata->file_header.e_machine == EM_ARM)
6629 printf (_("y (purecode), "));
6630 else if (filedata->file_header.e_machine == EM_PPC)
6631 printf (_("v (VLE), "));
6632 printf ("p (processor specific)\n");
6633 }
6634
6635 return TRUE;
6636}
6637
6638static const char *
6639get_group_flags (unsigned int flags)
6640{
6641 static char buff[128];
6642
6643 if (flags == 0)
6644 return "";
6645 else if (flags == GRP_COMDAT)
6646 return "COMDAT ";
6647
6648 snprintf (buff, 14, _("[0x%x: "), flags);
6649
6650 flags &= ~ GRP_COMDAT;
6651 if (flags & GRP_MASKOS)
6652 {
6653 strcat (buff, "<OS specific>");
6654 flags &= ~ GRP_MASKOS;
6655 }
6656
6657 if (flags & GRP_MASKPROC)
6658 {
6659 strcat (buff, "<PROC specific>");
6660 flags &= ~ GRP_MASKPROC;
6661 }
6662
6663 if (flags)
6664 strcat (buff, "<unknown>");
6665
6666 strcat (buff, "]");
6667 return buff;
6668}
6669
6670static bfd_boolean
6671process_section_groups (Filedata * filedata)
6672{
6673 Elf_Internal_Shdr * section;
6674 unsigned int i;
6675 struct group * group;
6676 Elf_Internal_Shdr * symtab_sec;
6677 Elf_Internal_Shdr * strtab_sec;
6678 Elf_Internal_Sym * symtab;
6679 unsigned long num_syms;
6680 char * strtab;
6681 size_t strtab_size;
6682
6683 /* Don't process section groups unless needed. */
6684 if (!do_unwind && !do_section_groups)
6685 return TRUE;
6686
6687 if (filedata->file_header.e_shnum == 0)
6688 {
6689 if (do_section_groups)
6690 printf (_("\nThere are no sections to group in this file.\n"));
6691
6692 return TRUE;
6693 }
6694
6695 if (filedata->section_headers == NULL)
6696 {
6697 error (_("Section headers are not available!\n"));
6698 /* PR 13622: This can happen with a corrupt ELF header. */
6699 return FALSE;
6700 }
6701
6702 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6703 sizeof (struct group *));
6704
6705 if (section_headers_groups == NULL)
6706 {
6707 error (_("Out of memory reading %u section group headers\n"),
6708 filedata->file_header.e_shnum);
6709 return FALSE;
6710 }
6711
6712 /* Scan the sections for the group section. */
6713 group_count = 0;
6714 for (i = 0, section = filedata->section_headers;
6715 i < filedata->file_header.e_shnum;
6716 i++, section++)
6717 if (section->sh_type == SHT_GROUP)
6718 group_count++;
6719
6720 if (group_count == 0)
6721 {
6722 if (do_section_groups)
6723 printf (_("\nThere are no section groups in this file.\n"));
6724
6725 return TRUE;
6726 }
6727
6728 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6729
6730 if (section_groups == NULL)
6731 {
6732 error (_("Out of memory reading %lu groups\n"),
6733 (unsigned long) group_count);
6734 return FALSE;
6735 }
6736
6737 symtab_sec = NULL;
6738 strtab_sec = NULL;
6739 symtab = NULL;
6740 num_syms = 0;
6741 strtab = NULL;
6742 strtab_size = 0;
6743 for (i = 0, section = filedata->section_headers, group = section_groups;
6744 i < filedata->file_header.e_shnum;
6745 i++, section++)
6746 {
6747 if (section->sh_type == SHT_GROUP)
6748 {
6749 const char * name = printable_section_name (filedata, section);
6750 const char * group_name;
6751 unsigned char * start;
6752 unsigned char * indices;
6753 unsigned int entry, j, size;
6754 Elf_Internal_Shdr * sec;
6755 Elf_Internal_Sym * sym;
6756
6757 /* Get the symbol table. */
6758 if (section->sh_link >= filedata->file_header.e_shnum
6759 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6760 != SHT_SYMTAB))
6761 {
6762 error (_("Bad sh_link in group section `%s'\n"), name);
6763 continue;
6764 }
6765
6766 if (symtab_sec != sec)
6767 {
6768 symtab_sec = sec;
6769 if (symtab)
6770 free (symtab);
6771 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6772 }
6773
6774 if (symtab == NULL)
6775 {
6776 error (_("Corrupt header in group section `%s'\n"), name);
6777 continue;
6778 }
6779
6780 if (section->sh_info >= num_syms)
6781 {
6782 error (_("Bad sh_info in group section `%s'\n"), name);
6783 continue;
6784 }
6785
6786 sym = symtab + section->sh_info;
6787
6788 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6789 {
6790 if (sym->st_shndx == 0
6791 || sym->st_shndx >= filedata->file_header.e_shnum)
6792 {
6793 error (_("Bad sh_info in group section `%s'\n"), name);
6794 continue;
6795 }
6796
6797 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6798 strtab_sec = NULL;
6799 if (strtab)
6800 free (strtab);
6801 strtab = NULL;
6802 strtab_size = 0;
6803 }
6804 else
6805 {
6806 /* Get the string table. */
6807 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6808 {
6809 strtab_sec = NULL;
6810 if (strtab)
6811 free (strtab);
6812 strtab = NULL;
6813 strtab_size = 0;
6814 }
6815 else if (strtab_sec
6816 != (sec = filedata->section_headers + symtab_sec->sh_link))
6817 {
6818 strtab_sec = sec;
6819 if (strtab)
6820 free (strtab);
6821
6822 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6823 1, strtab_sec->sh_size,
6824 _("string table"));
6825 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6826 }
6827 group_name = sym->st_name < strtab_size
6828 ? strtab + sym->st_name : _("<corrupt>");
6829 }
6830
6831 /* PR 17531: file: loop. */
6832 if (section->sh_entsize > section->sh_size)
6833 {
6834 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6835 printable_section_name (filedata, section),
6836 (unsigned long) section->sh_entsize,
6837 (unsigned long) section->sh_size);
6838 break;
6839 }
6840
6841 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6842 1, section->sh_size,
6843 _("section data"));
6844 if (start == NULL)
6845 continue;
6846
6847 indices = start;
6848 size = (section->sh_size / section->sh_entsize) - 1;
6849 entry = byte_get (indices, 4);
6850 indices += 4;
6851
6852 if (do_section_groups)
6853 {
6854 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6855 get_group_flags (entry), i, name, group_name, size);
6856
6857 printf (_(" [Index] Name\n"));
6858 }
6859
6860 group->group_index = i;
6861
6862 for (j = 0; j < size; j++)
6863 {
6864 struct group_list * g;
6865
6866 entry = byte_get (indices, 4);
6867 indices += 4;
6868
6869 if (entry >= filedata->file_header.e_shnum)
6870 {
6871 static unsigned num_group_errors = 0;
6872
6873 if (num_group_errors ++ < 10)
6874 {
6875 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6876 entry, i, filedata->file_header.e_shnum - 1);
6877 if (num_group_errors == 10)
6878 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6879 }
6880 continue;
6881 }
6882
6883 if (section_headers_groups [entry] != NULL)
6884 {
6885 if (entry)
6886 {
6887 static unsigned num_errs = 0;
6888
6889 if (num_errs ++ < 10)
6890 {
6891 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6892 entry, i,
6893 section_headers_groups [entry]->group_index);
6894 if (num_errs == 10)
6895 warn (_("Further error messages about already contained group sections suppressed\n"));
6896 }
6897 continue;
6898 }
6899 else
6900 {
6901 /* Intel C/C++ compiler may put section 0 in a
6902 section group. We just warn it the first time
6903 and ignore it afterwards. */
6904 static bfd_boolean warned = FALSE;
6905 if (!warned)
6906 {
6907 error (_("section 0 in group section [%5u]\n"),
6908 section_headers_groups [entry]->group_index);
6909 warned = TRUE;
6910 }
6911 }
6912 }
6913
6914 section_headers_groups [entry] = group;
6915
6916 if (do_section_groups)
6917 {
6918 sec = filedata->section_headers + entry;
6919 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6920 }
6921
6922 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6923 g->section_index = entry;
6924 g->next = group->root;
6925 group->root = g;
6926 }
6927
6928 if (start)
6929 free (start);
6930
6931 group++;
6932 }
6933 }
6934
6935 if (symtab)
6936 free (symtab);
6937 if (strtab)
6938 free (strtab);
6939 return TRUE;
6940}
6941
6942/* Data used to display dynamic fixups. */
6943
6944struct ia64_vms_dynfixup
6945{
6946 bfd_vma needed_ident; /* Library ident number. */
6947 bfd_vma needed; /* Index in the dstrtab of the library name. */
6948 bfd_vma fixup_needed; /* Index of the library. */
6949 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6950 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6951};
6952
6953/* Data used to display dynamic relocations. */
6954
6955struct ia64_vms_dynimgrela
6956{
6957 bfd_vma img_rela_cnt; /* Number of relocations. */
6958 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6959};
6960
6961/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6962 library). */
6963
6964static bfd_boolean
6965dump_ia64_vms_dynamic_fixups (Filedata * filedata,
6966 struct ia64_vms_dynfixup * fixup,
6967 const char * strtab,
6968 unsigned int strtab_sz)
6969{
6970 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6971 long i;
6972 const char * lib_name;
6973
6974 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6975 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6976 _("dynamic section image fixups"));
6977 if (!imfs)
6978 return FALSE;
6979
6980 if (fixup->needed < strtab_sz)
6981 lib_name = strtab + fixup->needed;
6982 else
6983 {
6984 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6985 (unsigned long) fixup->needed);
6986 lib_name = "???";
6987 }
6988 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6989 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6990 printf
6991 (_("Seg Offset Type SymVec DataType\n"));
6992
6993 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6994 {
6995 unsigned int type;
6996 const char *rtype;
6997
6998 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6999 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7000 type = BYTE_GET (imfs [i].type);
7001 rtype = elf_ia64_reloc_type (type);
7002 if (rtype == NULL)
7003 printf (" 0x%08x ", type);
7004 else
7005 printf (" %-32s ", rtype);
7006 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7007 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7008 }
7009
7010 free (imfs);
7011 return TRUE;
7012}
7013
7014/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7015
7016static bfd_boolean
7017dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7018{
7019 Elf64_External_VMS_IMAGE_RELA *imrs;
7020 long i;
7021
7022 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7023 1, imgrela->img_rela_cnt * sizeof (*imrs),
7024 _("dynamic section image relocations"));
7025 if (!imrs)
7026 return FALSE;
7027
7028 printf (_("\nImage relocs\n"));
7029 printf
7030 (_("Seg Offset Type Addend Seg Sym Off\n"));
7031
7032 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7033 {
7034 unsigned int type;
7035 const char *rtype;
7036
7037 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7038 printf ("%08" BFD_VMA_FMT "x ",
7039 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7040 type = BYTE_GET (imrs [i].type);
7041 rtype = elf_ia64_reloc_type (type);
7042 if (rtype == NULL)
7043 printf ("0x%08x ", type);
7044 else
7045 printf ("%-31s ", rtype);
7046 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7047 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7048 printf ("%08" BFD_VMA_FMT "x\n",
7049 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7050 }
7051
7052 free (imrs);
7053 return TRUE;
7054}
7055
7056/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7057
7058static bfd_boolean
7059process_ia64_vms_dynamic_relocs (Filedata * filedata)
7060{
7061 struct ia64_vms_dynfixup fixup;
7062 struct ia64_vms_dynimgrela imgrela;
7063 Elf_Internal_Dyn *entry;
7064 bfd_vma strtab_off = 0;
7065 bfd_vma strtab_sz = 0;
7066 char *strtab = NULL;
7067 bfd_boolean res = TRUE;
7068
7069 memset (&fixup, 0, sizeof (fixup));
7070 memset (&imgrela, 0, sizeof (imgrela));
7071
7072 /* Note: the order of the entries is specified by the OpenVMS specs. */
7073 for (entry = dynamic_section;
7074 entry < dynamic_section + dynamic_nent;
7075 entry++)
7076 {
7077 switch (entry->d_tag)
7078 {
7079 case DT_IA_64_VMS_STRTAB_OFFSET:
7080 strtab_off = entry->d_un.d_val;
7081 break;
7082 case DT_STRSZ:
7083 strtab_sz = entry->d_un.d_val;
7084 if (strtab == NULL)
7085 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7086 1, strtab_sz, _("dynamic string section"));
7087 break;
7088
7089 case DT_IA_64_VMS_NEEDED_IDENT:
7090 fixup.needed_ident = entry->d_un.d_val;
7091 break;
7092 case DT_NEEDED:
7093 fixup.needed = entry->d_un.d_val;
7094 break;
7095 case DT_IA_64_VMS_FIXUP_NEEDED:
7096 fixup.fixup_needed = entry->d_un.d_val;
7097 break;
7098 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7099 fixup.fixup_rela_cnt = entry->d_un.d_val;
7100 break;
7101 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7102 fixup.fixup_rela_off = entry->d_un.d_val;
7103 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7104 res = FALSE;
7105 break;
7106 case DT_IA_64_VMS_IMG_RELA_CNT:
7107 imgrela.img_rela_cnt = entry->d_un.d_val;
7108 break;
7109 case DT_IA_64_VMS_IMG_RELA_OFF:
7110 imgrela.img_rela_off = entry->d_un.d_val;
7111 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7112 res = FALSE;
7113 break;
7114
7115 default:
7116 break;
7117 }
7118 }
7119
7120 if (strtab != NULL)
7121 free (strtab);
7122
7123 return res;
7124}
7125
7126static struct
7127{
7128 const char * name;
7129 int reloc;
7130 int size;
7131 int rela;
7132}
7133 dynamic_relocations [] =
7134{
7135 { "REL", DT_REL, DT_RELSZ, FALSE },
7136 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7137 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7138};
7139
7140/* Process the reloc section. */
7141
7142static bfd_boolean
7143process_relocs (Filedata * filedata)
7144{
7145 unsigned long rel_size;
7146 unsigned long rel_offset;
7147
7148 if (!do_reloc)
7149 return TRUE;
7150
7151 if (do_using_dynamic)
7152 {
7153 int is_rela;
7154 const char * name;
7155 bfd_boolean has_dynamic_reloc;
7156 unsigned int i;
7157
7158 has_dynamic_reloc = FALSE;
7159
7160 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7161 {
7162 is_rela = dynamic_relocations [i].rela;
7163 name = dynamic_relocations [i].name;
7164 rel_size = dynamic_info [dynamic_relocations [i].size];
7165 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7166
7167 if (rel_size)
7168 has_dynamic_reloc = TRUE;
7169
7170 if (is_rela == UNKNOWN)
7171 {
7172 if (dynamic_relocations [i].reloc == DT_JMPREL)
7173 switch (dynamic_info[DT_PLTREL])
7174 {
7175 case DT_REL:
7176 is_rela = FALSE;
7177 break;
7178 case DT_RELA:
7179 is_rela = TRUE;
7180 break;
7181 }
7182 }
7183
7184 if (rel_size)
7185 {
7186 printf
7187 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7188 name, rel_offset, rel_size);
7189
7190 dump_relocations (filedata,
7191 offset_from_vma (filedata, rel_offset, rel_size),
7192 rel_size,
7193 dynamic_symbols, num_dynamic_syms,
7194 dynamic_strings, dynamic_strings_length,
7195 is_rela, TRUE /* is_dynamic */);
7196 }
7197 }
7198
7199 if (is_ia64_vms (filedata))
7200 if (process_ia64_vms_dynamic_relocs (filedata))
7201 has_dynamic_reloc = TRUE;
7202
7203 if (! has_dynamic_reloc)
7204 printf (_("\nThere are no dynamic relocations in this file.\n"));
7205 }
7206 else
7207 {
7208 Elf_Internal_Shdr * section;
7209 unsigned long i;
7210 bfd_boolean found = FALSE;
7211
7212 for (i = 0, section = filedata->section_headers;
7213 i < filedata->file_header.e_shnum;
7214 i++, section++)
7215 {
7216 if ( section->sh_type != SHT_RELA
7217 && section->sh_type != SHT_REL)
7218 continue;
7219
7220 rel_offset = section->sh_offset;
7221 rel_size = section->sh_size;
7222
7223 if (rel_size)
7224 {
7225 Elf_Internal_Shdr * strsec;
7226 int is_rela;
7227 unsigned long num_rela;
7228
7229 printf (_("\nRelocation section "));
7230
7231 if (filedata->string_table == NULL)
7232 printf ("%d", section->sh_name);
7233 else
7234 printf ("'%s'", printable_section_name (filedata, section));
7235
7236 num_rela = rel_size / section->sh_entsize;
7237 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7238 " at offset 0x%lx contains %lu entries:\n",
7239 num_rela),
7240 rel_offset, num_rela);
7241
7242 is_rela = section->sh_type == SHT_RELA;
7243
7244 if (section->sh_link != 0
7245 && section->sh_link < filedata->file_header.e_shnum)
7246 {
7247 Elf_Internal_Shdr * symsec;
7248 Elf_Internal_Sym * symtab;
7249 unsigned long nsyms;
7250 unsigned long strtablen = 0;
7251 char * strtab = NULL;
7252
7253 symsec = filedata->section_headers + section->sh_link;
7254 if (symsec->sh_type != SHT_SYMTAB
7255 && symsec->sh_type != SHT_DYNSYM)
7256 continue;
7257
7258 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7259
7260 if (symtab == NULL)
7261 continue;
7262
7263 if (symsec->sh_link != 0
7264 && symsec->sh_link < filedata->file_header.e_shnum)
7265 {
7266 strsec = filedata->section_headers + symsec->sh_link;
7267
7268 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7269 1, strsec->sh_size,
7270 _("string table"));
7271 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7272 }
7273
7274 dump_relocations (filedata, rel_offset, rel_size,
7275 symtab, nsyms, strtab, strtablen,
7276 is_rela,
7277 symsec->sh_type == SHT_DYNSYM);
7278 if (strtab)
7279 free (strtab);
7280 free (symtab);
7281 }
7282 else
7283 dump_relocations (filedata, rel_offset, rel_size,
7284 NULL, 0, NULL, 0, is_rela,
7285 FALSE /* is_dynamic */);
7286
7287 found = TRUE;
7288 }
7289 }
7290
7291 if (! found)
7292 {
7293 /* Users sometimes forget the -D option, so try to be helpful. */
7294 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7295 {
7296 if (dynamic_info [dynamic_relocations [i].size])
7297 {
7298 printf (_("\nThere are no static relocations in this file."));
7299 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7300
7301 break;
7302 }
7303 }
7304 if (i == ARRAY_SIZE (dynamic_relocations))
7305 printf (_("\nThere are no relocations in this file.\n"));
7306 }
7307 }
7308
7309 return TRUE;
7310}
7311
7312/* An absolute address consists of a section and an offset. If the
7313 section is NULL, the offset itself is the address, otherwise, the
7314 address equals to LOAD_ADDRESS(section) + offset. */
7315
7316struct absaddr
7317{
7318 unsigned short section;
7319 bfd_vma offset;
7320};
7321
7322#define ABSADDR(a) \
7323 ((a).section \
7324 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7325 : (a).offset)
7326
7327/* Find the nearest symbol at or below ADDR. Returns the symbol
7328 name, if found, and the offset from the symbol to ADDR. */
7329
7330static void
7331find_symbol_for_address (Filedata * filedata,
7332 Elf_Internal_Sym * symtab,
7333 unsigned long nsyms,
7334 const char * strtab,
7335 unsigned long strtab_size,
7336 struct absaddr addr,
7337 const char ** symname,
7338 bfd_vma * offset)
7339{
7340 bfd_vma dist = 0x100000;
7341 Elf_Internal_Sym * sym;
7342 Elf_Internal_Sym * beg;
7343 Elf_Internal_Sym * end;
7344 Elf_Internal_Sym * best = NULL;
7345
7346 REMOVE_ARCH_BITS (addr.offset);
7347 beg = symtab;
7348 end = symtab + nsyms;
7349
7350 while (beg < end)
7351 {
7352 bfd_vma value;
7353
7354 sym = beg + (end - beg) / 2;
7355
7356 value = sym->st_value;
7357 REMOVE_ARCH_BITS (value);
7358
7359 if (sym->st_name != 0
7360 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7361 && addr.offset >= value
7362 && addr.offset - value < dist)
7363 {
7364 best = sym;
7365 dist = addr.offset - value;
7366 if (!dist)
7367 break;
7368 }
7369
7370 if (addr.offset < value)
7371 end = sym;
7372 else
7373 beg = sym + 1;
7374 }
7375
7376 if (best)
7377 {
7378 *symname = (best->st_name >= strtab_size
7379 ? _("<corrupt>") : strtab + best->st_name);
7380 *offset = dist;
7381 return;
7382 }
7383
7384 *symname = NULL;
7385 *offset = addr.offset;
7386}
7387
7388static /* signed */ int
7389symcmp (const void *p, const void *q)
7390{
7391 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7392 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7393
7394 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7395}
7396
7397/* Process the unwind section. */
7398
7399#include "unwind-ia64.h"
7400
7401struct ia64_unw_table_entry
7402{
7403 struct absaddr start;
7404 struct absaddr end;
7405 struct absaddr info;
7406};
7407
7408struct ia64_unw_aux_info
7409{
7410 struct ia64_unw_table_entry * table; /* Unwind table. */
7411 unsigned long table_len; /* Length of unwind table. */
7412 unsigned char * info; /* Unwind info. */
7413 unsigned long info_size; /* Size of unwind info. */
7414 bfd_vma info_addr; /* Starting address of unwind info. */
7415 bfd_vma seg_base; /* Starting address of segment. */
7416 Elf_Internal_Sym * symtab; /* The symbol table. */
7417 unsigned long nsyms; /* Number of symbols. */
7418 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7419 unsigned long nfuns; /* Number of entries in funtab. */
7420 char * strtab; /* The string table. */
7421 unsigned long strtab_size; /* Size of string table. */
7422};
7423
7424static bfd_boolean
7425dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7426{
7427 struct ia64_unw_table_entry * tp;
7428 unsigned long j, nfuns;
7429 int in_body;
7430 bfd_boolean res = TRUE;
7431
7432 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7433 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7434 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7435 aux->funtab[nfuns++] = aux->symtab[j];
7436 aux->nfuns = nfuns;
7437 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7438
7439 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7440 {
7441 bfd_vma stamp;
7442 bfd_vma offset;
7443 const unsigned char * dp;
7444 const unsigned char * head;
7445 const unsigned char * end;
7446 const char * procname;
7447
7448 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7449 aux->strtab_size, tp->start, &procname, &offset);
7450
7451 fputs ("\n<", stdout);
7452
7453 if (procname)
7454 {
7455 fputs (procname, stdout);
7456
7457 if (offset)
7458 printf ("+%lx", (unsigned long) offset);
7459 }
7460
7461 fputs (">: [", stdout);
7462 print_vma (tp->start.offset, PREFIX_HEX);
7463 fputc ('-', stdout);
7464 print_vma (tp->end.offset, PREFIX_HEX);
7465 printf ("], info at +0x%lx\n",
7466 (unsigned long) (tp->info.offset - aux->seg_base));
7467
7468 /* PR 17531: file: 86232b32. */
7469 if (aux->info == NULL)
7470 continue;
7471
7472 /* PR 17531: file: 0997b4d1. */
7473 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7474 {
7475 warn (_("Invalid offset %lx in table entry %ld\n"),
7476 (long) tp->info.offset, (long) (tp - aux->table));
7477 res = FALSE;
7478 continue;
7479 }
7480
7481 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7482 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7483
7484 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7485 (unsigned) UNW_VER (stamp),
7486 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7487 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7488 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7489 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7490
7491 if (UNW_VER (stamp) != 1)
7492 {
7493 printf (_("\tUnknown version.\n"));
7494 continue;
7495 }
7496
7497 in_body = 0;
7498 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7499 /* PR 17531: file: 16ceda89. */
7500 if (end > aux->info + aux->info_size)
7501 end = aux->info + aux->info_size;
7502 for (dp = head + 8; dp < end;)
7503 dp = unw_decode (dp, in_body, & in_body, end);
7504 }
7505
7506 free (aux->funtab);
7507
7508 return res;
7509}
7510
7511static bfd_boolean
7512slurp_ia64_unwind_table (Filedata * filedata,
7513 struct ia64_unw_aux_info * aux,
7514 Elf_Internal_Shdr * sec)
7515{
7516 unsigned long size, nrelas, i;
7517 Elf_Internal_Phdr * seg;
7518 struct ia64_unw_table_entry * tep;
7519 Elf_Internal_Shdr * relsec;
7520 Elf_Internal_Rela * rela;
7521 Elf_Internal_Rela * rp;
7522 unsigned char * table;
7523 unsigned char * tp;
7524 Elf_Internal_Sym * sym;
7525 const char * relname;
7526
7527 aux->table_len = 0;
7528
7529 /* First, find the starting address of the segment that includes
7530 this section: */
7531
7532 if (filedata->file_header.e_phnum)
7533 {
7534 if (! get_program_headers (filedata))
7535 return FALSE;
7536
7537 for (seg = filedata->program_headers;
7538 seg < filedata->program_headers + filedata->file_header.e_phnum;
7539 ++seg)
7540 {
7541 if (seg->p_type != PT_LOAD)
7542 continue;
7543
7544 if (sec->sh_addr >= seg->p_vaddr
7545 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7546 {
7547 aux->seg_base = seg->p_vaddr;
7548 break;
7549 }
7550 }
7551 }
7552
7553 /* Second, build the unwind table from the contents of the unwind section: */
7554 size = sec->sh_size;
7555 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7556 _("unwind table"));
7557 if (!table)
7558 return FALSE;
7559
7560 aux->table_len = size / (3 * eh_addr_size);
7561 aux->table = (struct ia64_unw_table_entry *)
7562 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7563 tep = aux->table;
7564
7565 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7566 {
7567 tep->start.section = SHN_UNDEF;
7568 tep->end.section = SHN_UNDEF;
7569 tep->info.section = SHN_UNDEF;
7570 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7571 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7572 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7573 tep->start.offset += aux->seg_base;
7574 tep->end.offset += aux->seg_base;
7575 tep->info.offset += aux->seg_base;
7576 }
7577 free (table);
7578
7579 /* Third, apply any relocations to the unwind table: */
7580 for (relsec = filedata->section_headers;
7581 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7582 ++relsec)
7583 {
7584 if (relsec->sh_type != SHT_RELA
7585 || relsec->sh_info >= filedata->file_header.e_shnum
7586 || filedata->section_headers + relsec->sh_info != sec)
7587 continue;
7588
7589 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7590 & rela, & nrelas))
7591 {
7592 free (aux->table);
7593 aux->table = NULL;
7594 aux->table_len = 0;
7595 return FALSE;
7596 }
7597
7598 for (rp = rela; rp < rela + nrelas; ++rp)
7599 {
7600 relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7601 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7602
7603 /* PR 17531: file: 9fa67536. */
7604 if (relname == NULL)
7605 {
7606 warn (_("Skipping unknown relocation type: %u\n"),
7607 get_reloc_type (filedata, rp->r_info));
7608 continue;
7609 }
7610
7611 if (! const_strneq (relname, "R_IA64_SEGREL"))
7612 {
7613 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7614 continue;
7615 }
7616
7617 i = rp->r_offset / (3 * eh_addr_size);
7618
7619 /* PR 17531: file: 5bc8d9bf. */
7620 if (i >= aux->table_len)
7621 {
7622 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7623 continue;
7624 }
7625
7626 switch (rp->r_offset / eh_addr_size % 3)
7627 {
7628 case 0:
7629 aux->table[i].start.section = sym->st_shndx;
7630 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7631 break;
7632 case 1:
7633 aux->table[i].end.section = sym->st_shndx;
7634 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7635 break;
7636 case 2:
7637 aux->table[i].info.section = sym->st_shndx;
7638 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7639 break;
7640 default:
7641 break;
7642 }
7643 }
7644
7645 free (rela);
7646 }
7647
7648 return TRUE;
7649}
7650
7651static bfd_boolean
7652ia64_process_unwind (Filedata * filedata)
7653{
7654 Elf_Internal_Shdr * sec;
7655 Elf_Internal_Shdr * unwsec = NULL;
7656 Elf_Internal_Shdr * strsec;
7657 unsigned long i, unwcount = 0, unwstart = 0;
7658 struct ia64_unw_aux_info aux;
7659 bfd_boolean res = TRUE;
7660
7661 memset (& aux, 0, sizeof (aux));
7662
7663 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7664 {
7665 if (sec->sh_type == SHT_SYMTAB
7666 && sec->sh_link < filedata->file_header.e_shnum)
7667 {
7668 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7669
7670 strsec = filedata->section_headers + sec->sh_link;
7671 if (aux.strtab != NULL)
7672 {
7673 error (_("Multiple auxillary string tables encountered\n"));
7674 free (aux.strtab);
7675 res = FALSE;
7676 }
7677 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7678 1, strsec->sh_size,
7679 _("string table"));
7680 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7681 }
7682 else if (sec->sh_type == SHT_IA_64_UNWIND)
7683 unwcount++;
7684 }
7685
7686 if (!unwcount)
7687 printf (_("\nThere are no unwind sections in this file.\n"));
7688
7689 while (unwcount-- > 0)
7690 {
7691 char * suffix;
7692 size_t len, len2;
7693
7694 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7695 i < filedata->file_header.e_shnum; ++i, ++sec)
7696 if (sec->sh_type == SHT_IA_64_UNWIND)
7697 {
7698 unwsec = sec;
7699 break;
7700 }
7701 /* We have already counted the number of SHT_IA64_UNWIND
7702 sections so the loop above should never fail. */
7703 assert (unwsec != NULL);
7704
7705 unwstart = i + 1;
7706 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7707
7708 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7709 {
7710 /* We need to find which section group it is in. */
7711 struct group_list * g;
7712
7713 if (section_headers_groups == NULL
7714 || section_headers_groups [i] == NULL)
7715 i = filedata->file_header.e_shnum;
7716 else
7717 {
7718 g = section_headers_groups [i]->root;
7719
7720 for (; g != NULL; g = g->next)
7721 {
7722 sec = filedata->section_headers + g->section_index;
7723
7724 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7725 break;
7726 }
7727
7728 if (g == NULL)
7729 i = filedata->file_header.e_shnum;
7730 }
7731 }
7732 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7733 {
7734 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7735 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7736 suffix = SECTION_NAME (unwsec) + len;
7737 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7738 ++i, ++sec)
7739 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7740 && streq (SECTION_NAME (sec) + len2, suffix))
7741 break;
7742 }
7743 else
7744 {
7745 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7746 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7747 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7748 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7749 suffix = "";
7750 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7751 suffix = SECTION_NAME (unwsec) + len;
7752 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7753 ++i, ++sec)
7754 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7755 && streq (SECTION_NAME (sec) + len2, suffix))
7756 break;
7757 }
7758
7759 if (i == filedata->file_header.e_shnum)
7760 {
7761 printf (_("\nCould not find unwind info section for "));
7762
7763 if (filedata->string_table == NULL)
7764 printf ("%d", unwsec->sh_name);
7765 else
7766 printf ("'%s'", printable_section_name (filedata, unwsec));
7767 }
7768 else
7769 {
7770 aux.info_addr = sec->sh_addr;
7771 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7772 sec->sh_size,
7773 _("unwind info"));
7774 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7775
7776 printf (_("\nUnwind section "));
7777
7778 if (filedata->string_table == NULL)
7779 printf ("%d", unwsec->sh_name);
7780 else
7781 printf ("'%s'", printable_section_name (filedata, unwsec));
7782
7783 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7784 (unsigned long) unwsec->sh_offset,
7785 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7786
7787 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7788 && aux.table_len > 0)
7789 dump_ia64_unwind (filedata, & aux);
7790
7791 if (aux.table)
7792 free ((char *) aux.table);
7793 if (aux.info)
7794 free ((char *) aux.info);
7795 aux.table = NULL;
7796 aux.info = NULL;
7797 }
7798 }
7799
7800 if (aux.symtab)
7801 free (aux.symtab);
7802 if (aux.strtab)
7803 free ((char *) aux.strtab);
7804
7805 return res;
7806}
7807
7808struct hppa_unw_table_entry
7809{
7810 struct absaddr start;
7811 struct absaddr end;
7812 unsigned int Cannot_unwind:1; /* 0 */
7813 unsigned int Millicode:1; /* 1 */
7814 unsigned int Millicode_save_sr0:1; /* 2 */
7815 unsigned int Region_description:2; /* 3..4 */
7816 unsigned int reserved1:1; /* 5 */
7817 unsigned int Entry_SR:1; /* 6 */
7818 unsigned int Entry_FR:4; /* Number saved 7..10 */
7819 unsigned int Entry_GR:5; /* Number saved 11..15 */
7820 unsigned int Args_stored:1; /* 16 */
7821 unsigned int Variable_Frame:1; /* 17 */
7822 unsigned int Separate_Package_Body:1; /* 18 */
7823 unsigned int Frame_Extension_Millicode:1; /* 19 */
7824 unsigned int Stack_Overflow_Check:1; /* 20 */
7825 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7826 unsigned int Ada_Region:1; /* 22 */
7827 unsigned int cxx_info:1; /* 23 */
7828 unsigned int cxx_try_catch:1; /* 24 */
7829 unsigned int sched_entry_seq:1; /* 25 */
7830 unsigned int reserved2:1; /* 26 */
7831 unsigned int Save_SP:1; /* 27 */
7832 unsigned int Save_RP:1; /* 28 */
7833 unsigned int Save_MRP_in_frame:1; /* 29 */
7834 unsigned int extn_ptr_defined:1; /* 30 */
7835 unsigned int Cleanup_defined:1; /* 31 */
7836
7837 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7838 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7839 unsigned int Large_frame:1; /* 2 */
7840 unsigned int Pseudo_SP_Set:1; /* 3 */
7841 unsigned int reserved4:1; /* 4 */
7842 unsigned int Total_frame_size:27; /* 5..31 */
7843};
7844
7845struct hppa_unw_aux_info
7846{
7847 struct hppa_unw_table_entry * table; /* Unwind table. */
7848 unsigned long table_len; /* Length of unwind table. */
7849 bfd_vma seg_base; /* Starting address of segment. */
7850 Elf_Internal_Sym * symtab; /* The symbol table. */
7851 unsigned long nsyms; /* Number of symbols. */
7852 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7853 unsigned long nfuns; /* Number of entries in funtab. */
7854 char * strtab; /* The string table. */
7855 unsigned long strtab_size; /* Size of string table. */
7856};
7857
7858static bfd_boolean
7859dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7860{
7861 struct hppa_unw_table_entry * tp;
7862 unsigned long j, nfuns;
7863 bfd_boolean res = TRUE;
7864
7865 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7866 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7867 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7868 aux->funtab[nfuns++] = aux->symtab[j];
7869 aux->nfuns = nfuns;
7870 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7871
7872 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7873 {
7874 bfd_vma offset;
7875 const char * procname;
7876
7877 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7878 aux->strtab_size, tp->start, &procname,
7879 &offset);
7880
7881 fputs ("\n<", stdout);
7882
7883 if (procname)
7884 {
7885 fputs (procname, stdout);
7886
7887 if (offset)
7888 printf ("+%lx", (unsigned long) offset);
7889 }
7890
7891 fputs (">: [", stdout);
7892 print_vma (tp->start.offset, PREFIX_HEX);
7893 fputc ('-', stdout);
7894 print_vma (tp->end.offset, PREFIX_HEX);
7895 printf ("]\n\t");
7896
7897#define PF(_m) if (tp->_m) printf (#_m " ");
7898#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7899 PF(Cannot_unwind);
7900 PF(Millicode);
7901 PF(Millicode_save_sr0);
7902 /* PV(Region_description); */
7903 PF(Entry_SR);
7904 PV(Entry_FR);
7905 PV(Entry_GR);
7906 PF(Args_stored);
7907 PF(Variable_Frame);
7908 PF(Separate_Package_Body);
7909 PF(Frame_Extension_Millicode);
7910 PF(Stack_Overflow_Check);
7911 PF(Two_Instruction_SP_Increment);
7912 PF(Ada_Region);
7913 PF(cxx_info);
7914 PF(cxx_try_catch);
7915 PF(sched_entry_seq);
7916 PF(Save_SP);
7917 PF(Save_RP);
7918 PF(Save_MRP_in_frame);
7919 PF(extn_ptr_defined);
7920 PF(Cleanup_defined);
7921 PF(MPE_XL_interrupt_marker);
7922 PF(HP_UX_interrupt_marker);
7923 PF(Large_frame);
7924 PF(Pseudo_SP_Set);
7925 PV(Total_frame_size);
7926#undef PF
7927#undef PV
7928 }
7929
7930 printf ("\n");
7931
7932 free (aux->funtab);
7933
7934 return res;
7935}
7936
7937static bfd_boolean
7938slurp_hppa_unwind_table (Filedata * filedata,
7939 struct hppa_unw_aux_info * aux,
7940 Elf_Internal_Shdr * sec)
7941{
7942 unsigned long size, unw_ent_size, nentries, nrelas, i;
7943 Elf_Internal_Phdr * seg;
7944 struct hppa_unw_table_entry * tep;
7945 Elf_Internal_Shdr * relsec;
7946 Elf_Internal_Rela * rela;
7947 Elf_Internal_Rela * rp;
7948 unsigned char * table;
7949 unsigned char * tp;
7950 Elf_Internal_Sym * sym;
7951 const char * relname;
7952
7953 /* First, find the starting address of the segment that includes
7954 this section. */
7955 if (filedata->file_header.e_phnum)
7956 {
7957 if (! get_program_headers (filedata))
7958 return FALSE;
7959
7960 for (seg = filedata->program_headers;
7961 seg < filedata->program_headers + filedata->file_header.e_phnum;
7962 ++seg)
7963 {
7964 if (seg->p_type != PT_LOAD)
7965 continue;
7966
7967 if (sec->sh_addr >= seg->p_vaddr
7968 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7969 {
7970 aux->seg_base = seg->p_vaddr;
7971 break;
7972 }
7973 }
7974 }
7975
7976 /* Second, build the unwind table from the contents of the unwind
7977 section. */
7978 size = sec->sh_size;
7979 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7980 _("unwind table"));
7981 if (!table)
7982 return FALSE;
7983
7984 unw_ent_size = 16;
7985 nentries = size / unw_ent_size;
7986 size = unw_ent_size * nentries;
7987
7988 tep = aux->table = (struct hppa_unw_table_entry *)
7989 xcmalloc (nentries, sizeof (aux->table[0]));
7990
7991 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7992 {
7993 unsigned int tmp1, tmp2;
7994
7995 tep->start.section = SHN_UNDEF;
7996 tep->end.section = SHN_UNDEF;
7997
7998 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7999 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8000 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8001 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8002
8003 tep->start.offset += aux->seg_base;
8004 tep->end.offset += aux->seg_base;
8005
8006 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8007 tep->Millicode = (tmp1 >> 30) & 0x1;
8008 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8009 tep->Region_description = (tmp1 >> 27) & 0x3;
8010 tep->reserved1 = (tmp1 >> 26) & 0x1;
8011 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8012 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8013 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8014 tep->Args_stored = (tmp1 >> 15) & 0x1;
8015 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8016 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8017 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8018 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8019 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8020 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8021 tep->cxx_info = (tmp1 >> 8) & 0x1;
8022 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8023 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8024 tep->reserved2 = (tmp1 >> 5) & 0x1;
8025 tep->Save_SP = (tmp1 >> 4) & 0x1;
8026 tep->Save_RP = (tmp1 >> 3) & 0x1;
8027 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8028 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8029 tep->Cleanup_defined = tmp1 & 0x1;
8030
8031 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8032 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8033 tep->Large_frame = (tmp2 >> 29) & 0x1;
8034 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8035 tep->reserved4 = (tmp2 >> 27) & 0x1;
8036 tep->Total_frame_size = tmp2 & 0x7ffffff;
8037 }
8038 free (table);
8039
8040 /* Third, apply any relocations to the unwind table. */
8041 for (relsec = filedata->section_headers;
8042 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8043 ++relsec)
8044 {
8045 if (relsec->sh_type != SHT_RELA
8046 || relsec->sh_info >= filedata->file_header.e_shnum
8047 || filedata->section_headers + relsec->sh_info != sec)
8048 continue;
8049
8050 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8051 & rela, & nrelas))
8052 return FALSE;
8053
8054 for (rp = rela; rp < rela + nrelas; ++rp)
8055 {
8056 relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8057 sym = aux->symtab + get_reloc_symindex (rp->r_info);
8058
8059 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8060 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8061 {
8062 warn (_("Skipping unexpected relocation type %s\n"), relname);
8063 continue;
8064 }
8065
8066 i = rp->r_offset / unw_ent_size;
8067
8068 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8069 {
8070 case 0:
8071 aux->table[i].start.section = sym->st_shndx;
8072 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8073 break;
8074 case 1:
8075 aux->table[i].end.section = sym->st_shndx;
8076 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8077 break;
8078 default:
8079 break;
8080 }
8081 }
8082
8083 free (rela);
8084 }
8085
8086 aux->table_len = nentries;
8087
8088 return TRUE;
8089}
8090
8091static bfd_boolean
8092hppa_process_unwind (Filedata * filedata)
8093{
8094 struct hppa_unw_aux_info aux;
8095 Elf_Internal_Shdr * unwsec = NULL;
8096 Elf_Internal_Shdr * strsec;
8097 Elf_Internal_Shdr * sec;
8098 unsigned long i;
8099 bfd_boolean res = TRUE;
8100
8101 if (filedata->string_table == NULL)
8102 return FALSE;
8103
8104 memset (& aux, 0, sizeof (aux));
8105
8106 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8107 {
8108 if (sec->sh_type == SHT_SYMTAB
8109 && sec->sh_link < filedata->file_header.e_shnum)
8110 {
8111 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8112
8113 strsec = filedata->section_headers + sec->sh_link;
8114 if (aux.strtab != NULL)
8115 {
8116 error (_("Multiple auxillary string tables encountered\n"));
8117 free (aux.strtab);
8118 res = FALSE;
8119 }
8120 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8121 1, strsec->sh_size,
8122 _("string table"));
8123 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8124 }
8125 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8126 unwsec = sec;
8127 }
8128
8129 if (!unwsec)
8130 printf (_("\nThere are no unwind sections in this file.\n"));
8131
8132 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8133 {
8134 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8135 {
8136 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8137
8138 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8139 "contains %lu entry:\n",
8140 "\nUnwind section '%s' at offset 0x%lx "
8141 "contains %lu entries:\n",
8142 num_unwind),
8143 printable_section_name (filedata, sec),
8144 (unsigned long) sec->sh_offset,
8145 num_unwind);
8146
8147 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8148 res = FALSE;
8149
8150 if (res && aux.table_len > 0)
8151 {
8152 if (! dump_hppa_unwind (filedata, &aux))
8153 res = FALSE;
8154 }
8155
8156 if (aux.table)
8157 free ((char *) aux.table);
8158 aux.table = NULL;
8159 }
8160 }
8161
8162 if (aux.symtab)
8163 free (aux.symtab);
8164 if (aux.strtab)
8165 free ((char *) aux.strtab);
8166
8167 return res;
8168}
8169
8170struct arm_section
8171{
8172 unsigned char * data; /* The unwind data. */
8173 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8174 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8175 unsigned long nrelas; /* The number of relocations. */
8176 unsigned int rel_type; /* REL or RELA ? */
8177 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8178};
8179
8180struct arm_unw_aux_info
8181{
8182 Filedata * filedata; /* The file containing the unwind sections. */
8183 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8184 unsigned long nsyms; /* Number of symbols. */
8185 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8186 unsigned long nfuns; /* Number of these symbols. */
8187 char * strtab; /* The file's string table. */
8188 unsigned long strtab_size; /* Size of string table. */
8189};
8190
8191static const char *
8192arm_print_vma_and_name (Filedata * filedata,
8193 struct arm_unw_aux_info * aux,
8194 bfd_vma fn,
8195 struct absaddr addr)
8196{
8197 const char *procname;
8198 bfd_vma sym_offset;
8199
8200 if (addr.section == SHN_UNDEF)
8201 addr.offset = fn;
8202
8203 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8204 aux->strtab_size, addr, &procname,
8205 &sym_offset);
8206
8207 print_vma (fn, PREFIX_HEX);
8208
8209 if (procname)
8210 {
8211 fputs (" <", stdout);
8212 fputs (procname, stdout);
8213
8214 if (sym_offset)
8215 printf ("+0x%lx", (unsigned long) sym_offset);
8216 fputc ('>', stdout);
8217 }
8218
8219 return procname;
8220}
8221
8222static void
8223arm_free_section (struct arm_section *arm_sec)
8224{
8225 if (arm_sec->data != NULL)
8226 free (arm_sec->data);
8227
8228 if (arm_sec->rela != NULL)
8229 free (arm_sec->rela);
8230}
8231
8232/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8233 cached section and install SEC instead.
8234 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8235 and return its valued in * WORDP, relocating if necessary.
8236 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8237 relocation's offset in ADDR.
8238 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8239 into the string table of the symbol associated with the reloc. If no
8240 reloc was applied store -1 there.
8241 5) Return TRUE upon success, FALSE otherwise. */
8242
8243static bfd_boolean
8244get_unwind_section_word (Filedata * filedata,
8245 struct arm_unw_aux_info * aux,
8246 struct arm_section * arm_sec,
8247 Elf_Internal_Shdr * sec,
8248 bfd_vma word_offset,
8249 unsigned int * wordp,
8250 struct absaddr * addr,
8251 bfd_vma * sym_name)
8252{
8253 Elf_Internal_Rela *rp;
8254 Elf_Internal_Sym *sym;
8255 const char * relname;
8256 unsigned int word;
8257 bfd_boolean wrapped;
8258
8259 if (sec == NULL || arm_sec == NULL)
8260 return FALSE;
8261
8262 addr->section = SHN_UNDEF;
8263 addr->offset = 0;
8264
8265 if (sym_name != NULL)
8266 *sym_name = (bfd_vma) -1;
8267
8268 /* If necessary, update the section cache. */
8269 if (sec != arm_sec->sec)
8270 {
8271 Elf_Internal_Shdr *relsec;
8272
8273 arm_free_section (arm_sec);
8274
8275 arm_sec->sec = sec;
8276 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8277 sec->sh_size, _("unwind data"));
8278 arm_sec->rela = NULL;
8279 arm_sec->nrelas = 0;
8280
8281 for (relsec = filedata->section_headers;
8282 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8283 ++relsec)
8284 {
8285 if (relsec->sh_info >= filedata->file_header.e_shnum
8286 || filedata->section_headers + relsec->sh_info != sec
8287 /* PR 15745: Check the section type as well. */
8288 || (relsec->sh_type != SHT_REL
8289 && relsec->sh_type != SHT_RELA))
8290 continue;
8291
8292 arm_sec->rel_type = relsec->sh_type;
8293 if (relsec->sh_type == SHT_REL)
8294 {
8295 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8296 relsec->sh_size,
8297 & arm_sec->rela, & arm_sec->nrelas))
8298 return FALSE;
8299 }
8300 else /* relsec->sh_type == SHT_RELA */
8301 {
8302 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8303 relsec->sh_size,
8304 & arm_sec->rela, & arm_sec->nrelas))
8305 return FALSE;
8306 }
8307 break;
8308 }
8309
8310 arm_sec->next_rela = arm_sec->rela;
8311 }
8312
8313 /* If there is no unwind data we can do nothing. */
8314 if (arm_sec->data == NULL)
8315 return FALSE;
8316
8317 /* If the offset is invalid then fail. */
8318 if (/* PR 21343 *//* PR 18879 */
8319 sec->sh_size < 4
8320 || word_offset > (sec->sh_size - 4)
8321 || ((bfd_signed_vma) word_offset) < 0)
8322 return FALSE;
8323
8324 /* Get the word at the required offset. */
8325 word = byte_get (arm_sec->data + word_offset, 4);
8326
8327 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8328 if (arm_sec->rela == NULL)
8329 {
8330 * wordp = word;
8331 return TRUE;
8332 }
8333
8334 /* Look through the relocs to find the one that applies to the provided offset. */
8335 wrapped = FALSE;
8336 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8337 {
8338 bfd_vma prelval, offset;
8339
8340 if (rp->r_offset > word_offset && !wrapped)
8341 {
8342 rp = arm_sec->rela;
8343 wrapped = TRUE;
8344 }
8345 if (rp->r_offset > word_offset)
8346 break;
8347
8348 if (rp->r_offset & 3)
8349 {
8350 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8351 (unsigned long) rp->r_offset);
8352 continue;
8353 }
8354
8355 if (rp->r_offset < word_offset)
8356 continue;
8357
8358 /* PR 17531: file: 027-161405-0.004 */
8359 if (aux->symtab == NULL)
8360 continue;
8361
8362 if (arm_sec->rel_type == SHT_REL)
8363 {
8364 offset = word & 0x7fffffff;
8365 if (offset & 0x40000000)
8366 offset |= ~ (bfd_vma) 0x7fffffff;
8367 }
8368 else if (arm_sec->rel_type == SHT_RELA)
8369 offset = rp->r_addend;
8370 else
8371 {
8372 error (_("Unknown section relocation type %d encountered\n"),
8373 arm_sec->rel_type);
8374 break;
8375 }
8376
8377 /* PR 17531 file: 027-1241568-0.004. */
8378 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8379 {
8380 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8381 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8382 break;
8383 }
8384
8385 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8386 offset += sym->st_value;
8387 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8388
8389 /* Check that we are processing the expected reloc type. */
8390 if (filedata->file_header.e_machine == EM_ARM)
8391 {
8392 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8393 if (relname == NULL)
8394 {
8395 warn (_("Skipping unknown ARM relocation type: %d\n"),
8396 (int) ELF32_R_TYPE (rp->r_info));
8397 continue;
8398 }
8399
8400 if (streq (relname, "R_ARM_NONE"))
8401 continue;
8402
8403 if (! streq (relname, "R_ARM_PREL31"))
8404 {
8405 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8406 continue;
8407 }
8408 }
8409 else if (filedata->file_header.e_machine == EM_TI_C6000)
8410 {
8411 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8412 if (relname == NULL)
8413 {
8414 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8415 (int) ELF32_R_TYPE (rp->r_info));
8416 continue;
8417 }
8418
8419 if (streq (relname, "R_C6000_NONE"))
8420 continue;
8421
8422 if (! streq (relname, "R_C6000_PREL31"))
8423 {
8424 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8425 continue;
8426 }
8427
8428 prelval >>= 1;
8429 }
8430 else
8431 {
8432 /* This function currently only supports ARM and TI unwinders. */
8433 warn (_("Only TI and ARM unwinders are currently supported\n"));
8434 break;
8435 }
8436
8437 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8438 addr->section = sym->st_shndx;
8439 addr->offset = offset;
8440
8441 if (sym_name)
8442 * sym_name = sym->st_name;
8443 break;
8444 }
8445
8446 *wordp = word;
8447 arm_sec->next_rela = rp;
8448
8449 return TRUE;
8450}
8451
8452static const char *tic6x_unwind_regnames[16] =
8453{
8454 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8455 "A14", "A13", "A12", "A11", "A10",
8456 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8457};
8458
8459static void
8460decode_tic6x_unwind_regmask (unsigned int mask)
8461{
8462 int i;
8463
8464 for (i = 12; mask; mask >>= 1, i--)
8465 {
8466 if (mask & 1)
8467 {
8468 fputs (tic6x_unwind_regnames[i], stdout);
8469 if (mask > 1)
8470 fputs (", ", stdout);
8471 }
8472 }
8473}
8474
8475#define ADVANCE \
8476 if (remaining == 0 && more_words) \
8477 { \
8478 data_offset += 4; \
8479 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8480 data_offset, & word, & addr, NULL)) \
8481 return FALSE; \
8482 remaining = 4; \
8483 more_words--; \
8484 } \
8485
8486#define GET_OP(OP) \
8487 ADVANCE; \
8488 if (remaining) \
8489 { \
8490 remaining--; \
8491 (OP) = word >> 24; \
8492 word <<= 8; \
8493 } \
8494 else \
8495 { \
8496 printf (_("[Truncated opcode]\n")); \
8497 return FALSE; \
8498 } \
8499 printf ("0x%02x ", OP)
8500
8501static bfd_boolean
8502decode_arm_unwind_bytecode (Filedata * filedata,
8503 struct arm_unw_aux_info * aux,
8504 unsigned int word,
8505 unsigned int remaining,
8506 unsigned int more_words,
8507 bfd_vma data_offset,
8508 Elf_Internal_Shdr * data_sec,
8509 struct arm_section * data_arm_sec)
8510{
8511 struct absaddr addr;
8512 bfd_boolean res = TRUE;
8513
8514 /* Decode the unwinding instructions. */
8515 while (1)
8516 {
8517 unsigned int op, op2;
8518
8519 ADVANCE;
8520 if (remaining == 0)
8521 break;
8522 remaining--;
8523 op = word >> 24;
8524 word <<= 8;
8525
8526 printf (" 0x%02x ", op);
8527
8528 if ((op & 0xc0) == 0x00)
8529 {
8530 int offset = ((op & 0x3f) << 2) + 4;
8531
8532 printf (" vsp = vsp + %d", offset);
8533 }
8534 else if ((op & 0xc0) == 0x40)
8535 {
8536 int offset = ((op & 0x3f) << 2) + 4;
8537
8538 printf (" vsp = vsp - %d", offset);
8539 }
8540 else if ((op & 0xf0) == 0x80)
8541 {
8542 GET_OP (op2);
8543 if (op == 0x80 && op2 == 0)
8544 printf (_("Refuse to unwind"));
8545 else
8546 {
8547 unsigned int mask = ((op & 0x0f) << 8) | op2;
8548 bfd_boolean first = TRUE;
8549 int i;
8550
8551 printf ("pop {");
8552 for (i = 0; i < 12; i++)
8553 if (mask & (1 << i))
8554 {
8555 if (first)
8556 first = FALSE;
8557 else
8558 printf (", ");
8559 printf ("r%d", 4 + i);
8560 }
8561 printf ("}");
8562 }
8563 }
8564 else if ((op & 0xf0) == 0x90)
8565 {
8566 if (op == 0x9d || op == 0x9f)
8567 printf (_(" [Reserved]"));
8568 else
8569 printf (" vsp = r%d", op & 0x0f);
8570 }
8571 else if ((op & 0xf0) == 0xa0)
8572 {
8573 int end = 4 + (op & 0x07);
8574 bfd_boolean first = TRUE;
8575 int i;
8576
8577 printf (" pop {");
8578 for (i = 4; i <= end; i++)
8579 {
8580 if (first)
8581 first = FALSE;
8582 else
8583 printf (", ");
8584 printf ("r%d", i);
8585 }
8586 if (op & 0x08)
8587 {
8588 if (!first)
8589 printf (", ");
8590 printf ("r14");
8591 }
8592 printf ("}");
8593 }
8594 else if (op == 0xb0)
8595 printf (_(" finish"));
8596 else if (op == 0xb1)
8597 {
8598 GET_OP (op2);
8599 if (op2 == 0 || (op2 & 0xf0) != 0)
8600 printf (_("[Spare]"));
8601 else
8602 {
8603 unsigned int mask = op2 & 0x0f;
8604 bfd_boolean first = TRUE;
8605 int i;
8606
8607 printf ("pop {");
8608 for (i = 0; i < 12; i++)
8609 if (mask & (1 << i))
8610 {
8611 if (first)
8612 first = FALSE;
8613 else
8614 printf (", ");
8615 printf ("r%d", i);
8616 }
8617 printf ("}");
8618 }
8619 }
8620 else if (op == 0xb2)
8621 {
8622 unsigned char buf[9];
8623 unsigned int i, len;
8624 unsigned long offset;
8625
8626 for (i = 0; i < sizeof (buf); i++)
8627 {
8628 GET_OP (buf[i]);
8629 if ((buf[i] & 0x80) == 0)
8630 break;
8631 }
8632 if (i == sizeof (buf))
8633 {
8634 error (_("corrupt change to vsp"));
8635 res = FALSE;
8636 }
8637 else
8638 {
8639 offset = read_uleb128 (buf, &len, buf + i + 1);
8640 assert (len == i + 1);
8641 offset = offset * 4 + 0x204;
8642 printf ("vsp = vsp + %ld", offset);
8643 }
8644 }
8645 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8646 {
8647 unsigned int first, last;
8648
8649 GET_OP (op2);
8650 first = op2 >> 4;
8651 last = op2 & 0x0f;
8652 if (op == 0xc8)
8653 first = first + 16;
8654 printf ("pop {D%d", first);
8655 if (last)
8656 printf ("-D%d", first + last);
8657 printf ("}");
8658 }
8659 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8660 {
8661 unsigned int count = op & 0x07;
8662
8663 printf ("pop {D8");
8664 if (count)
8665 printf ("-D%d", 8 + count);
8666 printf ("}");
8667 }
8668 else if (op >= 0xc0 && op <= 0xc5)
8669 {
8670 unsigned int count = op & 0x07;
8671
8672 printf (" pop {wR10");
8673 if (count)
8674 printf ("-wR%d", 10 + count);
8675 printf ("}");
8676 }
8677 else if (op == 0xc6)
8678 {
8679 unsigned int first, last;
8680
8681 GET_OP (op2);
8682 first = op2 >> 4;
8683 last = op2 & 0x0f;
8684 printf ("pop {wR%d", first);
8685 if (last)
8686 printf ("-wR%d", first + last);
8687 printf ("}");
8688 }
8689 else if (op == 0xc7)
8690 {
8691 GET_OP (op2);
8692 if (op2 == 0 || (op2 & 0xf0) != 0)
8693 printf (_("[Spare]"));
8694 else
8695 {
8696 unsigned int mask = op2 & 0x0f;
8697 bfd_boolean first = TRUE;
8698 int i;
8699
8700 printf ("pop {");
8701 for (i = 0; i < 4; i++)
8702 if (mask & (1 << i))
8703 {
8704 if (first)
8705 first = FALSE;
8706 else
8707 printf (", ");
8708 printf ("wCGR%d", i);
8709 }
8710 printf ("}");
8711 }
8712 }
8713 else
8714 {
8715 printf (_(" [unsupported opcode]"));
8716 res = FALSE;
8717 }
8718
8719 printf ("\n");
8720 }
8721
8722 return res;
8723}
8724
8725static bfd_boolean
8726decode_tic6x_unwind_bytecode (Filedata * filedata,
8727 struct arm_unw_aux_info * aux,
8728 unsigned int word,
8729 unsigned int remaining,
8730 unsigned int more_words,
8731 bfd_vma data_offset,
8732 Elf_Internal_Shdr * data_sec,
8733 struct arm_section * data_arm_sec)
8734{
8735 struct absaddr addr;
8736
8737 /* Decode the unwinding instructions. */
8738 while (1)
8739 {
8740 unsigned int op, op2;
8741
8742 ADVANCE;
8743 if (remaining == 0)
8744 break;
8745 remaining--;
8746 op = word >> 24;
8747 word <<= 8;
8748
8749 printf (" 0x%02x ", op);
8750
8751 if ((op & 0xc0) == 0x00)
8752 {
8753 int offset = ((op & 0x3f) << 3) + 8;
8754 printf (" sp = sp + %d", offset);
8755 }
8756 else if ((op & 0xc0) == 0x80)
8757 {
8758 GET_OP (op2);
8759 if (op == 0x80 && op2 == 0)
8760 printf (_("Refuse to unwind"));
8761 else
8762 {
8763 unsigned int mask = ((op & 0x1f) << 8) | op2;
8764 if (op & 0x20)
8765 printf ("pop compact {");
8766 else
8767 printf ("pop {");
8768
8769 decode_tic6x_unwind_regmask (mask);
8770 printf("}");
8771 }
8772 }
8773 else if ((op & 0xf0) == 0xc0)
8774 {
8775 unsigned int reg;
8776 unsigned int nregs;
8777 unsigned int i;
8778 const char *name;
8779 struct
8780 {
8781 unsigned int offset;
8782 unsigned int reg;
8783 } regpos[16];
8784
8785 /* Scan entire instruction first so that GET_OP output is not
8786 interleaved with disassembly. */
8787 nregs = 0;
8788 for (i = 0; nregs < (op & 0xf); i++)
8789 {
8790 GET_OP (op2);
8791 reg = op2 >> 4;
8792 if (reg != 0xf)
8793 {
8794 regpos[nregs].offset = i * 2;
8795 regpos[nregs].reg = reg;
8796 nregs++;
8797 }
8798
8799 reg = op2 & 0xf;
8800 if (reg != 0xf)
8801 {
8802 regpos[nregs].offset = i * 2 + 1;
8803 regpos[nregs].reg = reg;
8804 nregs++;
8805 }
8806 }
8807
8808 printf (_("pop frame {"));
8809 reg = nregs - 1;
8810 for (i = i * 2; i > 0; i--)
8811 {
8812 if (regpos[reg].offset == i - 1)
8813 {
8814 name = tic6x_unwind_regnames[regpos[reg].reg];
8815 if (reg > 0)
8816 reg--;
8817 }
8818 else
8819 name = _("[pad]");
8820
8821 fputs (name, stdout);
8822 if (i > 1)
8823 printf (", ");
8824 }
8825
8826 printf ("}");
8827 }
8828 else if (op == 0xd0)
8829 printf (" MOV FP, SP");
8830 else if (op == 0xd1)
8831 printf (" __c6xabi_pop_rts");
8832 else if (op == 0xd2)
8833 {
8834 unsigned char buf[9];
8835 unsigned int i, len;
8836 unsigned long offset;
8837
8838 for (i = 0; i < sizeof (buf); i++)
8839 {
8840 GET_OP (buf[i]);
8841 if ((buf[i] & 0x80) == 0)
8842 break;
8843 }
8844 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8845 if (i == sizeof (buf))
8846 {
8847 warn (_("Corrupt stack pointer adjustment detected\n"));
8848 return FALSE;
8849 }
8850
8851 offset = read_uleb128 (buf, &len, buf + i + 1);
8852 assert (len == i + 1);
8853 offset = offset * 8 + 0x408;
8854 printf (_("sp = sp + %ld"), offset);
8855 }
8856 else if ((op & 0xf0) == 0xe0)
8857 {
8858 if ((op & 0x0f) == 7)
8859 printf (" RETURN");
8860 else
8861 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8862 }
8863 else
8864 {
8865 printf (_(" [unsupported opcode]"));
8866 }
8867 putchar ('\n');
8868 }
8869
8870 return TRUE;
8871}
8872
8873static bfd_vma
8874arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8875{
8876 bfd_vma offset;
8877
8878 offset = word & 0x7fffffff;
8879 if (offset & 0x40000000)
8880 offset |= ~ (bfd_vma) 0x7fffffff;
8881
8882 if (filedata->file_header.e_machine == EM_TI_C6000)
8883 offset <<= 1;
8884
8885 return offset + where;
8886}
8887
8888static bfd_boolean
8889decode_arm_unwind (Filedata * filedata,
8890 struct arm_unw_aux_info * aux,
8891 unsigned int word,
8892 unsigned int remaining,
8893 bfd_vma data_offset,
8894 Elf_Internal_Shdr * data_sec,
8895 struct arm_section * data_arm_sec)
8896{
8897 int per_index;
8898 unsigned int more_words = 0;
8899 struct absaddr addr;
8900 bfd_vma sym_name = (bfd_vma) -1;
8901 bfd_boolean res = TRUE;
8902
8903 if (remaining == 0)
8904 {
8905 /* Fetch the first word.
8906 Note - when decoding an object file the address extracted
8907 here will always be 0. So we also pass in the sym_name
8908 parameter so that we can find the symbol associated with
8909 the personality routine. */
8910 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8911 & word, & addr, & sym_name))
8912 return FALSE;
8913
8914 remaining = 4;
8915 }
8916
8917 if ((word & 0x80000000) == 0)
8918 {
8919 /* Expand prel31 for personality routine. */
8920 bfd_vma fn;
8921 const char *procname;
8922
8923 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8924 printf (_(" Personality routine: "));
8925 if (fn == 0
8926 && addr.section == SHN_UNDEF && addr.offset == 0
8927 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8928 {
8929 procname = aux->strtab + sym_name;
8930 print_vma (fn, PREFIX_HEX);
8931 if (procname)
8932 {
8933 fputs (" <", stdout);
8934 fputs (procname, stdout);
8935 fputc ('>', stdout);
8936 }
8937 }
8938 else
8939 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8940 fputc ('\n', stdout);
8941
8942 /* The GCC personality routines use the standard compact
8943 encoding, starting with one byte giving the number of
8944 words. */
8945 if (procname != NULL
8946 && (const_strneq (procname, "__gcc_personality_v0")
8947 || const_strneq (procname, "__gxx_personality_v0")
8948 || const_strneq (procname, "__gcj_personality_v0")
8949 || const_strneq (procname, "__gnu_objc_personality_v0")))
8950 {
8951 remaining = 0;
8952 more_words = 1;
8953 ADVANCE;
8954 if (!remaining)
8955 {
8956 printf (_(" [Truncated data]\n"));
8957 return FALSE;
8958 }
8959 more_words = word >> 24;
8960 word <<= 8;
8961 remaining--;
8962 per_index = -1;
8963 }
8964 else
8965 return TRUE;
8966 }
8967 else
8968 {
8969 /* ARM EHABI Section 6.3:
8970
8971 An exception-handling table entry for the compact model looks like:
8972
8973 31 30-28 27-24 23-0
8974 -- ----- ----- ----
8975 1 0 index Data for personalityRoutine[index] */
8976
8977 if (filedata->file_header.e_machine == EM_ARM
8978 && (word & 0x70000000))
8979 {
8980 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8981 res = FALSE;
8982 }
8983
8984 per_index = (word >> 24) & 0x7f;
8985 printf (_(" Compact model index: %d\n"), per_index);
8986 if (per_index == 0)
8987 {
8988 more_words = 0;
8989 word <<= 8;
8990 remaining--;
8991 }
8992 else if (per_index < 3)
8993 {
8994 more_words = (word >> 16) & 0xff;
8995 word <<= 16;
8996 remaining -= 2;
8997 }
8998 }
8999
9000 switch (filedata->file_header.e_machine)
9001 {
9002 case EM_ARM:
9003 if (per_index < 3)
9004 {
9005 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9006 data_offset, data_sec, data_arm_sec))
9007 res = FALSE;
9008 }
9009 else
9010 {
9011 warn (_("Unknown ARM compact model index encountered\n"));
9012 printf (_(" [reserved]\n"));
9013 res = FALSE;
9014 }
9015 break;
9016
9017 case EM_TI_C6000:
9018 if (per_index < 3)
9019 {
9020 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9021 data_offset, data_sec, data_arm_sec))
9022 res = FALSE;
9023 }
9024 else if (per_index < 5)
9025 {
9026 if (((word >> 17) & 0x7f) == 0x7f)
9027 printf (_(" Restore stack from frame pointer\n"));
9028 else
9029 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9030 printf (_(" Registers restored: "));
9031 if (per_index == 4)
9032 printf (" (compact) ");
9033 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9034 putchar ('\n');
9035 printf (_(" Return register: %s\n"),
9036 tic6x_unwind_regnames[word & 0xf]);
9037 }
9038 else
9039 printf (_(" [reserved (%d)]\n"), per_index);
9040 break;
9041
9042 default:
9043 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9044 filedata->file_header.e_machine);
9045 res = FALSE;
9046 }
9047
9048 /* Decode the descriptors. Not implemented. */
9049
9050 return res;
9051}
9052
9053static bfd_boolean
9054dump_arm_unwind (Filedata * filedata,
9055 struct arm_unw_aux_info * aux,
9056 Elf_Internal_Shdr * exidx_sec)
9057{
9058 struct arm_section exidx_arm_sec, extab_arm_sec;
9059 unsigned int i, exidx_len;
9060 unsigned long j, nfuns;
9061 bfd_boolean res = TRUE;
9062
9063 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9064 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9065 exidx_len = exidx_sec->sh_size / 8;
9066
9067 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9068 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9069 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9070 aux->funtab[nfuns++] = aux->symtab[j];
9071 aux->nfuns = nfuns;
9072 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9073
9074 for (i = 0; i < exidx_len; i++)
9075 {
9076 unsigned int exidx_fn, exidx_entry;
9077 struct absaddr fn_addr, entry_addr;
9078 bfd_vma fn;
9079
9080 fputc ('\n', stdout);
9081
9082 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9083 8 * i, & exidx_fn, & fn_addr, NULL)
9084 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9085 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9086 {
9087 free (aux->funtab);
9088 arm_free_section (& exidx_arm_sec);
9089 arm_free_section (& extab_arm_sec);
9090 return FALSE;
9091 }
9092
9093 /* ARM EHABI, Section 5:
9094 An index table entry consists of 2 words.
9095 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9096 if (exidx_fn & 0x80000000)
9097 {
9098 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9099 res = FALSE;
9100 }
9101
9102 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9103
9104 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9105 fputs (": ", stdout);
9106
9107 if (exidx_entry == 1)
9108 {
9109 print_vma (exidx_entry, PREFIX_HEX);
9110 fputs (" [cantunwind]\n", stdout);
9111 }
9112 else if (exidx_entry & 0x80000000)
9113 {
9114 print_vma (exidx_entry, PREFIX_HEX);
9115 fputc ('\n', stdout);
9116 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9117 }
9118 else
9119 {
9120 bfd_vma table, table_offset = 0;
9121 Elf_Internal_Shdr *table_sec;
9122
9123 fputs ("@", stdout);
9124 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9125 print_vma (table, PREFIX_HEX);
9126 printf ("\n");
9127
9128 /* Locate the matching .ARM.extab. */
9129 if (entry_addr.section != SHN_UNDEF
9130 && entry_addr.section < filedata->file_header.e_shnum)
9131 {
9132 table_sec = filedata->section_headers + entry_addr.section;
9133 table_offset = entry_addr.offset;
9134 /* PR 18879 */
9135 if (table_offset > table_sec->sh_size
9136 || ((bfd_signed_vma) table_offset) < 0)
9137 {
9138 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9139 (unsigned long) table_offset,
9140 printable_section_name (filedata, table_sec));
9141 res = FALSE;
9142 continue;
9143 }
9144 }
9145 else
9146 {
9147 table_sec = find_section_by_address (filedata, table);
9148 if (table_sec != NULL)
9149 table_offset = table - table_sec->sh_addr;
9150 }
9151
9152 if (table_sec == NULL)
9153 {
9154 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9155 (unsigned long) table);
9156 res = FALSE;
9157 continue;
9158 }
9159
9160 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9161 &extab_arm_sec))
9162 res = FALSE;
9163 }
9164 }
9165
9166 printf ("\n");
9167
9168 free (aux->funtab);
9169 arm_free_section (&exidx_arm_sec);
9170 arm_free_section (&extab_arm_sec);
9171
9172 return res;
9173}
9174
9175/* Used for both ARM and C6X unwinding tables. */
9176
9177static bfd_boolean
9178arm_process_unwind (Filedata * filedata)
9179{
9180 struct arm_unw_aux_info aux;
9181 Elf_Internal_Shdr *unwsec = NULL;
9182 Elf_Internal_Shdr *strsec;
9183 Elf_Internal_Shdr *sec;
9184 unsigned long i;
9185 unsigned int sec_type;
9186 bfd_boolean res = TRUE;
9187
9188 switch (filedata->file_header.e_machine)
9189 {
9190 case EM_ARM:
9191 sec_type = SHT_ARM_EXIDX;
9192 break;
9193
9194 case EM_TI_C6000:
9195 sec_type = SHT_C6000_UNWIND;
9196 break;
9197
9198 default:
9199 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9200 filedata->file_header.e_machine);
9201 return FALSE;
9202 }
9203
9204 if (filedata->string_table == NULL)
9205 return FALSE;
9206
9207 memset (& aux, 0, sizeof (aux));
9208 aux.filedata = filedata;
9209
9210 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9211 {
9212 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9213 {
9214 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9215
9216 strsec = filedata->section_headers + sec->sh_link;
9217
9218 /* PR binutils/17531 file: 011-12666-0.004. */
9219 if (aux.strtab != NULL)
9220 {
9221 error (_("Multiple string tables found in file.\n"));
9222 free (aux.strtab);
9223 res = FALSE;
9224 }
9225 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9226 1, strsec->sh_size, _("string table"));
9227 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9228 }
9229 else if (sec->sh_type == sec_type)
9230 unwsec = sec;
9231 }
9232
9233 if (unwsec == NULL)
9234 printf (_("\nThere are no unwind sections in this file.\n"));
9235 else
9236 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9237 {
9238 if (sec->sh_type == sec_type)
9239 {
9240 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9241 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9242 "contains %lu entry:\n",
9243 "\nUnwind section '%s' at offset 0x%lx "
9244 "contains %lu entries:\n",
9245 num_unwind),
9246 printable_section_name (filedata, sec),
9247 (unsigned long) sec->sh_offset,
9248 num_unwind);
9249
9250 if (! dump_arm_unwind (filedata, &aux, sec))
9251 res = FALSE;
9252 }
9253 }
9254
9255 if (aux.symtab)
9256 free (aux.symtab);
9257 if (aux.strtab)
9258 free ((char *) aux.strtab);
9259
9260 return res;
9261}
9262
9263static bfd_boolean
9264process_unwind (Filedata * filedata)
9265{
9266 struct unwind_handler
9267 {
9268 unsigned int machtype;
9269 bfd_boolean (* handler)(Filedata *);
9270 } handlers[] =
9271 {
9272 { EM_ARM, arm_process_unwind },
9273 { EM_IA_64, ia64_process_unwind },
9274 { EM_PARISC, hppa_process_unwind },
9275 { EM_TI_C6000, arm_process_unwind },
9276 { 0, NULL }
9277 };
9278 int i;
9279
9280 if (!do_unwind)
9281 return TRUE;
9282
9283 for (i = 0; handlers[i].handler != NULL; i++)
9284 if (filedata->file_header.e_machine == handlers[i].machtype)
9285 return handlers[i].handler (filedata);
9286
9287 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9288 get_machine_name (filedata->file_header.e_machine));
9289 return TRUE;
9290}
9291
9292static void
9293dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9294{
9295 switch (entry->d_tag)
9296 {
9297 case DT_MIPS_FLAGS:
9298 if (entry->d_un.d_val == 0)
9299 printf (_("NONE"));
9300 else
9301 {
9302 static const char * opts[] =
9303 {
9304 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9305 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9306 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9307 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9308 "RLD_ORDER_SAFE"
9309 };
9310 unsigned int cnt;
9311 bfd_boolean first = TRUE;
9312
9313 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9314 if (entry->d_un.d_val & (1 << cnt))
9315 {
9316 printf ("%s%s", first ? "" : " ", opts[cnt]);
9317 first = FALSE;
9318 }
9319 }
9320 break;
9321
9322 case DT_MIPS_IVERSION:
9323 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9324 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9325 else
9326 {
9327 char buf[40];
9328 sprintf_vma (buf, entry->d_un.d_ptr);
9329 /* Note: coded this way so that there is a single string for translation. */
9330 printf (_("<corrupt: %s>"), buf);
9331 }
9332 break;
9333
9334 case DT_MIPS_TIME_STAMP:
9335 {
9336 char timebuf[128];
9337 struct tm * tmp;
9338 time_t atime = entry->d_un.d_val;
9339
9340 tmp = gmtime (&atime);
9341 /* PR 17531: file: 6accc532. */
9342 if (tmp == NULL)
9343 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9344 else
9345 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9346 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9347 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9348 printf (_("Time Stamp: %s"), timebuf);
9349 }
9350 break;
9351
9352 case DT_MIPS_RLD_VERSION:
9353 case DT_MIPS_LOCAL_GOTNO:
9354 case DT_MIPS_CONFLICTNO:
9355 case DT_MIPS_LIBLISTNO:
9356 case DT_MIPS_SYMTABNO:
9357 case DT_MIPS_UNREFEXTNO:
9358 case DT_MIPS_HIPAGENO:
9359 case DT_MIPS_DELTA_CLASS_NO:
9360 case DT_MIPS_DELTA_INSTANCE_NO:
9361 case DT_MIPS_DELTA_RELOC_NO:
9362 case DT_MIPS_DELTA_SYM_NO:
9363 case DT_MIPS_DELTA_CLASSSYM_NO:
9364 case DT_MIPS_COMPACT_SIZE:
9365 print_vma (entry->d_un.d_val, DEC);
9366 break;
9367
9368 default:
9369 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9370 }
9371 putchar ('\n');
9372}
9373
9374static void
9375dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9376{
9377 switch (entry->d_tag)
9378 {
9379 case DT_HP_DLD_FLAGS:
9380 {
9381 static struct
9382 {
9383 long int bit;
9384 const char * str;
9385 }
9386 flags[] =
9387 {
9388 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9389 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9390 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9391 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9392 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9393 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9394 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9395 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9396 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9397 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9398 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9399 { DT_HP_GST, "HP_GST" },
9400 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9401 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9402 { DT_HP_NODELETE, "HP_NODELETE" },
9403 { DT_HP_GROUP, "HP_GROUP" },
9404 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9405 };
9406 bfd_boolean first = TRUE;
9407 size_t cnt;
9408 bfd_vma val = entry->d_un.d_val;
9409
9410 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9411 if (val & flags[cnt].bit)
9412 {
9413 if (! first)
9414 putchar (' ');
9415 fputs (flags[cnt].str, stdout);
9416 first = FALSE;
9417 val ^= flags[cnt].bit;
9418 }
9419
9420 if (val != 0 || first)
9421 {
9422 if (! first)
9423 putchar (' ');
9424 print_vma (val, HEX);
9425 }
9426 }
9427 break;
9428
9429 default:
9430 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9431 break;
9432 }
9433 putchar ('\n');
9434}
9435
9436#ifdef BFD64
9437
9438/* VMS vs Unix time offset and factor. */
9439
9440#define VMS_EPOCH_OFFSET 35067168000000000LL
9441#define VMS_GRANULARITY_FACTOR 10000000
9442
9443/* Display a VMS time in a human readable format. */
9444
9445static void
9446print_vms_time (bfd_int64_t vmstime)
9447{
9448 struct tm *tm;
9449 time_t unxtime;
9450
9451 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9452 tm = gmtime (&unxtime);
9453 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9454 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9455 tm->tm_hour, tm->tm_min, tm->tm_sec);
9456}
9457#endif /* BFD64 */
9458
9459static void
9460dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9461{
9462 switch (entry->d_tag)
9463 {
9464 case DT_IA_64_PLT_RESERVE:
9465 /* First 3 slots reserved. */
9466 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9467 printf (" -- ");
9468 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9469 break;
9470
9471 case DT_IA_64_VMS_LINKTIME:
9472#ifdef BFD64
9473 print_vms_time (entry->d_un.d_val);
9474#endif
9475 break;
9476
9477 case DT_IA_64_VMS_LNKFLAGS:
9478 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9479 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9480 printf (" CALL_DEBUG");
9481 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9482 printf (" NOP0BUFS");
9483 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9484 printf (" P0IMAGE");
9485 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9486 printf (" MKTHREADS");
9487 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9488 printf (" UPCALLS");
9489 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9490 printf (" IMGSTA");
9491 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9492 printf (" INITIALIZE");
9493 if (entry->d_un.d_val & VMS_LF_MAIN)
9494 printf (" MAIN");
9495 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9496 printf (" EXE_INIT");
9497 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9498 printf (" TBK_IN_IMG");
9499 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9500 printf (" DBG_IN_IMG");
9501 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9502 printf (" TBK_IN_DSF");
9503 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9504 printf (" DBG_IN_DSF");
9505 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9506 printf (" SIGNATURES");
9507 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9508 printf (" REL_SEG_OFF");
9509 break;
9510
9511 default:
9512 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9513 break;
9514 }
9515 putchar ('\n');
9516}
9517
9518static bfd_boolean
9519get_32bit_dynamic_section (Filedata * filedata)
9520{
9521 Elf32_External_Dyn * edyn;
9522 Elf32_External_Dyn * ext;
9523 Elf_Internal_Dyn * entry;
9524
9525 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9526 dynamic_size, _("dynamic section"));
9527 if (!edyn)
9528 return FALSE;
9529
9530 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9531 might not have the luxury of section headers. Look for the DT_NULL
9532 terminator to determine the number of entries. */
9533 for (ext = edyn, dynamic_nent = 0;
9534 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9535 ext++)
9536 {
9537 dynamic_nent++;
9538 if (BYTE_GET (ext->d_tag) == DT_NULL)
9539 break;
9540 }
9541
9542 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9543 sizeof (* entry));
9544 if (dynamic_section == NULL)
9545 {
9546 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9547 (unsigned long) dynamic_nent);
9548 free (edyn);
9549 return FALSE;
9550 }
9551
9552 for (ext = edyn, entry = dynamic_section;
9553 entry < dynamic_section + dynamic_nent;
9554 ext++, entry++)
9555 {
9556 entry->d_tag = BYTE_GET (ext->d_tag);
9557 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9558 }
9559
9560 free (edyn);
9561
9562 return TRUE;
9563}
9564
9565static bfd_boolean
9566get_64bit_dynamic_section (Filedata * filedata)
9567{
9568 Elf64_External_Dyn * edyn;
9569 Elf64_External_Dyn * ext;
9570 Elf_Internal_Dyn * entry;
9571
9572 /* Read in the data. */
9573 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9574 dynamic_size, _("dynamic section"));
9575 if (!edyn)
9576 return FALSE;
9577
9578 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9579 might not have the luxury of section headers. Look for the DT_NULL
9580 terminator to determine the number of entries. */
9581 for (ext = edyn, dynamic_nent = 0;
9582 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9583 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9584 ext++)
9585 {
9586 dynamic_nent++;
9587 if (BYTE_GET (ext->d_tag) == DT_NULL)
9588 break;
9589 }
9590
9591 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9592 sizeof (* entry));
9593 if (dynamic_section == NULL)
9594 {
9595 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9596 (unsigned long) dynamic_nent);
9597 free (edyn);
9598 return FALSE;
9599 }
9600
9601 /* Convert from external to internal formats. */
9602 for (ext = edyn, entry = dynamic_section;
9603 entry < dynamic_section + dynamic_nent;
9604 ext++, entry++)
9605 {
9606 entry->d_tag = BYTE_GET (ext->d_tag);
9607 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9608 }
9609
9610 free (edyn);
9611
9612 return TRUE;
9613}
9614
9615static void
9616print_dynamic_flags (bfd_vma flags)
9617{
9618 bfd_boolean first = TRUE;
9619
9620 while (flags)
9621 {
9622 bfd_vma flag;
9623
9624 flag = flags & - flags;
9625 flags &= ~ flag;
9626
9627 if (first)
9628 first = FALSE;
9629 else
9630 putc (' ', stdout);
9631
9632 switch (flag)
9633 {
9634 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9635 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9636 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9637 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9638 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9639 default: fputs (_("unknown"), stdout); break;
9640 }
9641 }
9642 puts ("");
9643}
9644
9645/* Parse and display the contents of the dynamic section. */
9646
9647static bfd_boolean
9648process_dynamic_section (Filedata * filedata)
9649{
9650 Elf_Internal_Dyn * entry;
9651
9652 if (dynamic_size == 0)
9653 {
9654 if (do_dynamic)
9655 printf (_("\nThere is no dynamic section in this file.\n"));
9656
9657 return TRUE;
9658 }
9659
9660 if (is_32bit_elf)
9661 {
9662 if (! get_32bit_dynamic_section (filedata))
9663 return FALSE;
9664 }
9665 else
9666 {
9667 if (! get_64bit_dynamic_section (filedata))
9668 return FALSE;
9669 }
9670
9671 /* Find the appropriate symbol table. */
9672 if (dynamic_symbols == NULL)
9673 {
9674 for (entry = dynamic_section;
9675 entry < dynamic_section + dynamic_nent;
9676 ++entry)
9677 {
9678 Elf_Internal_Shdr section;
9679
9680 if (entry->d_tag != DT_SYMTAB)
9681 continue;
9682
9683 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9684
9685 /* Since we do not know how big the symbol table is,
9686 we default to reading in the entire file (!) and
9687 processing that. This is overkill, I know, but it
9688 should work. */
9689 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9690 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9691 {
9692 /* See PR 21379 for a reproducer. */
9693 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9694 return FALSE;
9695 }
9696
9697 if (archive_file_offset != 0)
9698 section.sh_size = archive_file_size - section.sh_offset;
9699 else
9700 section.sh_size = filedata->file_size - section.sh_offset;
9701
9702 if (is_32bit_elf)
9703 section.sh_entsize = sizeof (Elf32_External_Sym);
9704 else
9705 section.sh_entsize = sizeof (Elf64_External_Sym);
9706 section.sh_name = filedata->string_table_length;
9707
9708 if (dynamic_symbols != NULL)
9709 {
9710 error (_("Multiple dynamic symbol table sections found\n"));
9711 free (dynamic_symbols);
9712 }
9713 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9714 if (num_dynamic_syms < 1)
9715 {
9716 error (_("Unable to determine the number of symbols to load\n"));
9717 continue;
9718 }
9719 }
9720 }
9721
9722 /* Similarly find a string table. */
9723 if (dynamic_strings == NULL)
9724 {
9725 for (entry = dynamic_section;
9726 entry < dynamic_section + dynamic_nent;
9727 ++entry)
9728 {
9729 unsigned long offset;
9730 long str_tab_len;
9731
9732 if (entry->d_tag != DT_STRTAB)
9733 continue;
9734
9735 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9736
9737 /* Since we do not know how big the string table is,
9738 we default to reading in the entire file (!) and
9739 processing that. This is overkill, I know, but it
9740 should work. */
9741
9742 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9743
9744 if (archive_file_offset != 0)
9745 str_tab_len = archive_file_size - offset;
9746 else
9747 str_tab_len = filedata->file_size - offset;
9748
9749 if (str_tab_len < 1)
9750 {
9751 error
9752 (_("Unable to determine the length of the dynamic string table\n"));
9753 continue;
9754 }
9755
9756 if (dynamic_strings != NULL)
9757 {
9758 error (_("Multiple dynamic string tables found\n"));
9759 free (dynamic_strings);
9760 }
9761
9762 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9763 str_tab_len,
9764 _("dynamic string table"));
9765 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9766 }
9767 }
9768
9769 /* And find the syminfo section if available. */
9770 if (dynamic_syminfo == NULL)
9771 {
9772 unsigned long syminsz = 0;
9773
9774 for (entry = dynamic_section;
9775 entry < dynamic_section + dynamic_nent;
9776 ++entry)
9777 {
9778 if (entry->d_tag == DT_SYMINENT)
9779 {
9780 /* Note: these braces are necessary to avoid a syntax
9781 error from the SunOS4 C compiler. */
9782 /* PR binutils/17531: A corrupt file can trigger this test.
9783 So do not use an assert, instead generate an error message. */
9784 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9785 error (_("Bad value (%d) for SYMINENT entry\n"),
9786 (int) entry->d_un.d_val);
9787 }
9788 else if (entry->d_tag == DT_SYMINSZ)
9789 syminsz = entry->d_un.d_val;
9790 else if (entry->d_tag == DT_SYMINFO)
9791 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9792 syminsz);
9793 }
9794
9795 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9796 {
9797 Elf_External_Syminfo * extsyminfo;
9798 Elf_External_Syminfo * extsym;
9799 Elf_Internal_Syminfo * syminfo;
9800
9801 /* There is a syminfo section. Read the data. */
9802 extsyminfo = (Elf_External_Syminfo *)
9803 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9804 _("symbol information"));
9805 if (!extsyminfo)
9806 return FALSE;
9807
9808 if (dynamic_syminfo != NULL)
9809 {
9810 error (_("Multiple dynamic symbol information sections found\n"));
9811 free (dynamic_syminfo);
9812 }
9813 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9814 if (dynamic_syminfo == NULL)
9815 {
9816 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9817 (unsigned long) syminsz);
9818 return FALSE;
9819 }
9820
9821 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9822 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9823 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9824 ++syminfo, ++extsym)
9825 {
9826 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9827 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9828 }
9829
9830 free (extsyminfo);
9831 }
9832 }
9833
9834 if (do_dynamic && dynamic_addr)
9835 printf (ngettext ("\nDynamic section at offset 0x%lx "
9836 "contains %lu entry:\n",
9837 "\nDynamic section at offset 0x%lx "
9838 "contains %lu entries:\n",
9839 dynamic_nent),
9840 dynamic_addr, (unsigned long) dynamic_nent);
9841 if (do_dynamic)
9842 printf (_(" Tag Type Name/Value\n"));
9843
9844 for (entry = dynamic_section;
9845 entry < dynamic_section + dynamic_nent;
9846 entry++)
9847 {
9848 if (do_dynamic)
9849 {
9850 const char * dtype;
9851
9852 putchar (' ');
9853 print_vma (entry->d_tag, FULL_HEX);
9854 dtype = get_dynamic_type (filedata, entry->d_tag);
9855 printf (" (%s)%*s", dtype,
9856 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9857 }
9858
9859 switch (entry->d_tag)
9860 {
9861 case DT_FLAGS:
9862 if (do_dynamic)
9863 print_dynamic_flags (entry->d_un.d_val);
9864 break;
9865
9866 case DT_AUXILIARY:
9867 case DT_FILTER:
9868 case DT_CONFIG:
9869 case DT_DEPAUDIT:
9870 case DT_AUDIT:
9871 if (do_dynamic)
9872 {
9873 switch (entry->d_tag)
9874 {
9875 case DT_AUXILIARY:
9876 printf (_("Auxiliary library"));
9877 break;
9878
9879 case DT_FILTER:
9880 printf (_("Filter library"));
9881 break;
9882
9883 case DT_CONFIG:
9884 printf (_("Configuration file"));
9885 break;
9886
9887 case DT_DEPAUDIT:
9888 printf (_("Dependency audit library"));
9889 break;
9890
9891 case DT_AUDIT:
9892 printf (_("Audit library"));
9893 break;
9894 }
9895
9896 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9897 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9898 else
9899 {
9900 printf (": ");
9901 print_vma (entry->d_un.d_val, PREFIX_HEX);
9902 putchar ('\n');
9903 }
9904 }
9905 break;
9906
9907 case DT_FEATURE:
9908 if (do_dynamic)
9909 {
9910 printf (_("Flags:"));
9911
9912 if (entry->d_un.d_val == 0)
9913 printf (_(" None\n"));
9914 else
9915 {
9916 unsigned long int val = entry->d_un.d_val;
9917
9918 if (val & DTF_1_PARINIT)
9919 {
9920 printf (" PARINIT");
9921 val ^= DTF_1_PARINIT;
9922 }
9923 if (val & DTF_1_CONFEXP)
9924 {
9925 printf (" CONFEXP");
9926 val ^= DTF_1_CONFEXP;
9927 }
9928 if (val != 0)
9929 printf (" %lx", val);
9930 puts ("");
9931 }
9932 }
9933 break;
9934
9935 case DT_POSFLAG_1:
9936 if (do_dynamic)
9937 {
9938 printf (_("Flags:"));
9939
9940 if (entry->d_un.d_val == 0)
9941 printf (_(" None\n"));
9942 else
9943 {
9944 unsigned long int val = entry->d_un.d_val;
9945
9946 if (val & DF_P1_LAZYLOAD)
9947 {
9948 printf (" LAZYLOAD");
9949 val ^= DF_P1_LAZYLOAD;
9950 }
9951 if (val & DF_P1_GROUPPERM)
9952 {
9953 printf (" GROUPPERM");
9954 val ^= DF_P1_GROUPPERM;
9955 }
9956 if (val != 0)
9957 printf (" %lx", val);
9958 puts ("");
9959 }
9960 }
9961 break;
9962
9963 case DT_FLAGS_1:
9964 if (do_dynamic)
9965 {
9966 printf (_("Flags:"));
9967 if (entry->d_un.d_val == 0)
9968 printf (_(" None\n"));
9969 else
9970 {
9971 unsigned long int val = entry->d_un.d_val;
9972
9973 if (val & DF_1_NOW)
9974 {
9975 printf (" NOW");
9976 val ^= DF_1_NOW;
9977 }
9978 if (val & DF_1_GLOBAL)
9979 {
9980 printf (" GLOBAL");
9981 val ^= DF_1_GLOBAL;
9982 }
9983 if (val & DF_1_GROUP)
9984 {
9985 printf (" GROUP");
9986 val ^= DF_1_GROUP;
9987 }
9988 if (val & DF_1_NODELETE)
9989 {
9990 printf (" NODELETE");
9991 val ^= DF_1_NODELETE;
9992 }
9993 if (val & DF_1_LOADFLTR)
9994 {
9995 printf (" LOADFLTR");
9996 val ^= DF_1_LOADFLTR;
9997 }
9998 if (val & DF_1_INITFIRST)
9999 {
10000 printf (" INITFIRST");
10001 val ^= DF_1_INITFIRST;
10002 }
10003 if (val & DF_1_NOOPEN)
10004 {
10005 printf (" NOOPEN");
10006 val ^= DF_1_NOOPEN;
10007 }
10008 if (val & DF_1_ORIGIN)
10009 {
10010 printf (" ORIGIN");
10011 val ^= DF_1_ORIGIN;
10012 }
10013 if (val & DF_1_DIRECT)
10014 {
10015 printf (" DIRECT");
10016 val ^= DF_1_DIRECT;
10017 }
10018 if (val & DF_1_TRANS)
10019 {
10020 printf (" TRANS");
10021 val ^= DF_1_TRANS;
10022 }
10023 if (val & DF_1_INTERPOSE)
10024 {
10025 printf (" INTERPOSE");
10026 val ^= DF_1_INTERPOSE;
10027 }
10028 if (val & DF_1_NODEFLIB)
10029 {
10030 printf (" NODEFLIB");
10031 val ^= DF_1_NODEFLIB;
10032 }
10033 if (val & DF_1_NODUMP)
10034 {
10035 printf (" NODUMP");
10036 val ^= DF_1_NODUMP;
10037 }
10038 if (val & DF_1_CONFALT)
10039 {
10040 printf (" CONFALT");
10041 val ^= DF_1_CONFALT;
10042 }
10043 if (val & DF_1_ENDFILTEE)
10044 {
10045 printf (" ENDFILTEE");
10046 val ^= DF_1_ENDFILTEE;
10047 }
10048 if (val & DF_1_DISPRELDNE)
10049 {
10050 printf (" DISPRELDNE");
10051 val ^= DF_1_DISPRELDNE;
10052 }
10053 if (val & DF_1_DISPRELPND)
10054 {
10055 printf (" DISPRELPND");
10056 val ^= DF_1_DISPRELPND;
10057 }
10058 if (val & DF_1_NODIRECT)
10059 {
10060 printf (" NODIRECT");
10061 val ^= DF_1_NODIRECT;
10062 }
10063 if (val & DF_1_IGNMULDEF)
10064 {
10065 printf (" IGNMULDEF");
10066 val ^= DF_1_IGNMULDEF;
10067 }
10068 if (val & DF_1_NOKSYMS)
10069 {
10070 printf (" NOKSYMS");
10071 val ^= DF_1_NOKSYMS;
10072 }
10073 if (val & DF_1_NOHDR)
10074 {
10075 printf (" NOHDR");
10076 val ^= DF_1_NOHDR;
10077 }
10078 if (val & DF_1_EDITED)
10079 {
10080 printf (" EDITED");
10081 val ^= DF_1_EDITED;
10082 }
10083 if (val & DF_1_NORELOC)
10084 {
10085 printf (" NORELOC");
10086 val ^= DF_1_NORELOC;
10087 }
10088 if (val & DF_1_SYMINTPOSE)
10089 {
10090 printf (" SYMINTPOSE");
10091 val ^= DF_1_SYMINTPOSE;
10092 }
10093 if (val & DF_1_GLOBAUDIT)
10094 {
10095 printf (" GLOBAUDIT");
10096 val ^= DF_1_GLOBAUDIT;
10097 }
10098 if (val & DF_1_SINGLETON)
10099 {
10100 printf (" SINGLETON");
10101 val ^= DF_1_SINGLETON;
10102 }
10103 if (val & DF_1_STUB)
10104 {
10105 printf (" STUB");
10106 val ^= DF_1_STUB;
10107 }
10108 if (val & DF_1_PIE)
10109 {
10110 printf (" PIE");
10111 val ^= DF_1_PIE;
10112 }
10113 if (val & DF_1_KMOD)
10114 {
10115 printf (" KMOD");
10116 val ^= DF_1_KMOD;
10117 }
10118 if (val & DF_1_WEAKFILTER)
10119 {
10120 printf (" WEAKFILTER");
10121 val ^= DF_1_WEAKFILTER;
10122 }
10123 if (val & DF_1_NOCOMMON)
10124 {
10125 printf (" NOCOMMON");
10126 val ^= DF_1_NOCOMMON;
10127 }
10128 if (val != 0)
10129 printf (" %lx", val);
10130 puts ("");
10131 }
10132 }
10133 break;
10134
10135 case DT_PLTREL:
10136 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10137 if (do_dynamic)
10138 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10139 break;
10140
10141 case DT_NULL :
10142 case DT_NEEDED :
10143 case DT_PLTGOT :
10144 case DT_HASH :
10145 case DT_STRTAB :
10146 case DT_SYMTAB :
10147 case DT_RELA :
10148 case DT_INIT :
10149 case DT_FINI :
10150 case DT_SONAME :
10151 case DT_RPATH :
10152 case DT_SYMBOLIC:
10153 case DT_REL :
10154 case DT_DEBUG :
10155 case DT_TEXTREL :
10156 case DT_JMPREL :
10157 case DT_RUNPATH :
10158 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10159
10160 if (do_dynamic)
10161 {
10162 char * name;
10163
10164 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10165 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10166 else
10167 name = NULL;
10168
10169 if (name)
10170 {
10171 switch (entry->d_tag)
10172 {
10173 case DT_NEEDED:
10174 printf (_("Shared library: [%s]"), name);
10175
10176 if (streq (name, program_interpreter))
10177 printf (_(" program interpreter"));
10178 break;
10179
10180 case DT_SONAME:
10181 printf (_("Library soname: [%s]"), name);
10182 break;
10183
10184 case DT_RPATH:
10185 printf (_("Library rpath: [%s]"), name);
10186 break;
10187
10188 case DT_RUNPATH:
10189 printf (_("Library runpath: [%s]"), name);
10190 break;
10191
10192 default:
10193 print_vma (entry->d_un.d_val, PREFIX_HEX);
10194 break;
10195 }
10196 }
10197 else
10198 print_vma (entry->d_un.d_val, PREFIX_HEX);
10199
10200 putchar ('\n');
10201 }
10202 break;
10203
10204 case DT_PLTRELSZ:
10205 case DT_RELASZ :
10206 case DT_STRSZ :
10207 case DT_RELSZ :
10208 case DT_RELAENT :
10209 case DT_SYMENT :
10210 case DT_RELENT :
10211 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10212 /* Fall through. */
10213 case DT_PLTPADSZ:
10214 case DT_MOVEENT :
10215 case DT_MOVESZ :
10216 case DT_INIT_ARRAYSZ:
10217 case DT_FINI_ARRAYSZ:
10218 case DT_GNU_CONFLICTSZ:
10219 case DT_GNU_LIBLISTSZ:
10220 if (do_dynamic)
10221 {
10222 print_vma (entry->d_un.d_val, UNSIGNED);
10223 printf (_(" (bytes)\n"));
10224 }
10225 break;
10226
10227 case DT_VERDEFNUM:
10228 case DT_VERNEEDNUM:
10229 case DT_RELACOUNT:
10230 case DT_RELCOUNT:
10231 if (do_dynamic)
10232 {
10233 print_vma (entry->d_un.d_val, UNSIGNED);
10234 putchar ('\n');
10235 }
10236 break;
10237
10238 case DT_SYMINSZ:
10239 case DT_SYMINENT:
10240 case DT_SYMINFO:
10241 case DT_USED:
10242 case DT_INIT_ARRAY:
10243 case DT_FINI_ARRAY:
10244 if (do_dynamic)
10245 {
10246 if (entry->d_tag == DT_USED
10247 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10248 {
10249 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10250
10251 if (*name)
10252 {
10253 printf (_("Not needed object: [%s]\n"), name);
10254 break;
10255 }
10256 }
10257
10258 print_vma (entry->d_un.d_val, PREFIX_HEX);
10259 putchar ('\n');
10260 }
10261 break;
10262
10263 case DT_BIND_NOW:
10264 /* The value of this entry is ignored. */
10265 if (do_dynamic)
10266 putchar ('\n');
10267 break;
10268
10269 case DT_GNU_PRELINKED:
10270 if (do_dynamic)
10271 {
10272 struct tm * tmp;
10273 time_t atime = entry->d_un.d_val;
10274
10275 tmp = gmtime (&atime);
10276 /* PR 17533 file: 041-1244816-0.004. */
10277 if (tmp == NULL)
10278 printf (_("<corrupt time val: %lx"),
10279 (unsigned long) atime);
10280 else
10281 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10282 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10283 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10284
10285 }
10286 break;
10287
10288 case DT_GNU_HASH:
10289 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10290 if (do_dynamic)
10291 {
10292 print_vma (entry->d_un.d_val, PREFIX_HEX);
10293 putchar ('\n');
10294 }
10295 break;
10296
10297 default:
10298 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10299 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10300 entry->d_un.d_val;
10301
10302 if (do_dynamic)
10303 {
10304 switch (filedata->file_header.e_machine)
10305 {
10306 case EM_MIPS:
10307 case EM_MIPS_RS3_LE:
10308 dynamic_section_mips_val (entry);
10309 break;
10310 case EM_PARISC:
10311 dynamic_section_parisc_val (entry);
10312 break;
10313 case EM_IA_64:
10314 dynamic_section_ia64_val (entry);
10315 break;
10316 default:
10317 print_vma (entry->d_un.d_val, PREFIX_HEX);
10318 putchar ('\n');
10319 }
10320 }
10321 break;
10322 }
10323 }
10324
10325 return TRUE;
10326}
10327
10328static char *
10329get_ver_flags (unsigned int flags)
10330{
10331 static char buff[128];
10332
10333 buff[0] = 0;
10334
10335 if (flags == 0)
10336 return _("none");
10337
10338 if (flags & VER_FLG_BASE)
10339 strcat (buff, "BASE");
10340
10341 if (flags & VER_FLG_WEAK)
10342 {
10343 if (flags & VER_FLG_BASE)
10344 strcat (buff, " | ");
10345
10346 strcat (buff, "WEAK");
10347 }
10348
10349 if (flags & VER_FLG_INFO)
10350 {
10351 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10352 strcat (buff, " | ");
10353
10354 strcat (buff, "INFO");
10355 }
10356
10357 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10358 {
10359 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10360 strcat (buff, " | ");
10361
10362 strcat (buff, _("<unknown>"));
10363 }
10364
10365 return buff;
10366}
10367
10368/* Display the contents of the version sections. */
10369
10370static bfd_boolean
10371process_version_sections (Filedata * filedata)
10372{
10373 Elf_Internal_Shdr * section;
10374 unsigned i;
10375 bfd_boolean found = FALSE;
10376
10377 if (! do_version)
10378 return TRUE;
10379
10380 for (i = 0, section = filedata->section_headers;
10381 i < filedata->file_header.e_shnum;
10382 i++, section++)
10383 {
10384 switch (section->sh_type)
10385 {
10386 case SHT_GNU_verdef:
10387 {
10388 Elf_External_Verdef * edefs;
10389 unsigned long idx;
10390 unsigned long cnt;
10391 char * endbuf;
10392
10393 found = TRUE;
10394
10395 printf (ngettext ("\nVersion definition section '%s' "
10396 "contains %u entry:\n",
10397 "\nVersion definition section '%s' "
10398 "contains %u entries:\n",
10399 section->sh_info),
10400 printable_section_name (filedata, section),
10401 section->sh_info);
10402
10403 printf (_(" Addr: 0x"));
10404 printf_vma (section->sh_addr);
10405 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10406 (unsigned long) section->sh_offset, section->sh_link,
10407 printable_section_name_from_index (filedata, section->sh_link));
10408
10409 edefs = (Elf_External_Verdef *)
10410 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10411 _("version definition section"));
10412 if (!edefs)
10413 break;
10414 endbuf = (char *) edefs + section->sh_size;
10415
10416 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10417 {
10418 char * vstart;
10419 Elf_External_Verdef * edef;
10420 Elf_Internal_Verdef ent;
10421 Elf_External_Verdaux * eaux;
10422 Elf_Internal_Verdaux aux;
10423 unsigned long isum;
10424 int j;
10425
10426 vstart = ((char *) edefs) + idx;
10427 if (vstart + sizeof (*edef) > endbuf)
10428 break;
10429
10430 edef = (Elf_External_Verdef *) vstart;
10431
10432 ent.vd_version = BYTE_GET (edef->vd_version);
10433 ent.vd_flags = BYTE_GET (edef->vd_flags);
10434 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10435 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10436 ent.vd_hash = BYTE_GET (edef->vd_hash);
10437 ent.vd_aux = BYTE_GET (edef->vd_aux);
10438 ent.vd_next = BYTE_GET (edef->vd_next);
10439
10440 printf (_(" %#06lx: Rev: %d Flags: %s"),
10441 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10442
10443 printf (_(" Index: %d Cnt: %d "),
10444 ent.vd_ndx, ent.vd_cnt);
10445
10446 /* Check for overflow. */
10447 if (ent.vd_aux > (size_t) (endbuf - vstart))
10448 break;
10449
10450 vstart += ent.vd_aux;
10451
10452 if (vstart + sizeof (*eaux) > endbuf)
10453 break;
10454 eaux = (Elf_External_Verdaux *) vstart;
10455
10456 aux.vda_name = BYTE_GET (eaux->vda_name);
10457 aux.vda_next = BYTE_GET (eaux->vda_next);
10458
10459 if (VALID_DYNAMIC_NAME (aux.vda_name))
10460 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10461 else
10462 printf (_("Name index: %ld\n"), aux.vda_name);
10463
10464 isum = idx + ent.vd_aux;
10465
10466 for (j = 1; j < ent.vd_cnt; j++)
10467 {
10468 if (aux.vda_next < sizeof (*eaux)
10469 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10470 {
10471 warn (_("Invalid vda_next field of %lx\n"),
10472 aux.vda_next);
10473 j = ent.vd_cnt;
10474 break;
10475 }
10476 /* Check for overflow. */
10477 if (aux.vda_next > (size_t) (endbuf - vstart))
10478 break;
10479
10480 isum += aux.vda_next;
10481 vstart += aux.vda_next;
10482
10483 if (vstart + sizeof (*eaux) > endbuf)
10484 break;
10485 eaux = (Elf_External_Verdaux *) vstart;
10486
10487 aux.vda_name = BYTE_GET (eaux->vda_name);
10488 aux.vda_next = BYTE_GET (eaux->vda_next);
10489
10490 if (VALID_DYNAMIC_NAME (aux.vda_name))
10491 printf (_(" %#06lx: Parent %d: %s\n"),
10492 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10493 else
10494 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10495 isum, j, aux.vda_name);
10496 }
10497
10498 if (j < ent.vd_cnt)
10499 printf (_(" Version def aux past end of section\n"));
10500
10501 /* PR 17531:
10502 file: id:000001,src:000172+005151,op:splice,rep:2. */
10503 if (ent.vd_next < sizeof (*edef)
10504 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10505 {
10506 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10507 cnt = section->sh_info;
10508 break;
10509 }
10510 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10511 break;
10512
10513 idx += ent.vd_next;
10514 }
10515
10516 if (cnt < section->sh_info)
10517 printf (_(" Version definition past end of section\n"));
10518
10519 free (edefs);
10520 }
10521 break;
10522
10523 case SHT_GNU_verneed:
10524 {
10525 Elf_External_Verneed * eneed;
10526 unsigned long idx;
10527 unsigned long cnt;
10528 char * endbuf;
10529
10530 found = TRUE;
10531
10532 printf (ngettext ("\nVersion needs section '%s' "
10533 "contains %u entry:\n",
10534 "\nVersion needs section '%s' "
10535 "contains %u entries:\n",
10536 section->sh_info),
10537 printable_section_name (filedata, section), section->sh_info);
10538
10539 printf (_(" Addr: 0x"));
10540 printf_vma (section->sh_addr);
10541 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10542 (unsigned long) section->sh_offset, section->sh_link,
10543 printable_section_name_from_index (filedata, section->sh_link));
10544
10545 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10546 section->sh_offset, 1,
10547 section->sh_size,
10548 _("Version Needs section"));
10549 if (!eneed)
10550 break;
10551 endbuf = (char *) eneed + section->sh_size;
10552
10553 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10554 {
10555 Elf_External_Verneed * entry;
10556 Elf_Internal_Verneed ent;
10557 unsigned long isum;
10558 int j;
10559 char * vstart;
10560
10561 vstart = ((char *) eneed) + idx;
10562 if (vstart + sizeof (*entry) > endbuf)
10563 break;
10564
10565 entry = (Elf_External_Verneed *) vstart;
10566
10567 ent.vn_version = BYTE_GET (entry->vn_version);
10568 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10569 ent.vn_file = BYTE_GET (entry->vn_file);
10570 ent.vn_aux = BYTE_GET (entry->vn_aux);
10571 ent.vn_next = BYTE_GET (entry->vn_next);
10572
10573 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10574
10575 if (VALID_DYNAMIC_NAME (ent.vn_file))
10576 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10577 else
10578 printf (_(" File: %lx"), ent.vn_file);
10579
10580 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10581
10582 /* Check for overflow. */
10583 if (ent.vn_aux > (size_t) (endbuf - vstart))
10584 break;
10585 vstart += ent.vn_aux;
10586
10587 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10588 {
10589 Elf_External_Vernaux * eaux;
10590 Elf_Internal_Vernaux aux;
10591
10592 if (vstart + sizeof (*eaux) > endbuf)
10593 break;
10594 eaux = (Elf_External_Vernaux *) vstart;
10595
10596 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10597 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10598 aux.vna_other = BYTE_GET (eaux->vna_other);
10599 aux.vna_name = BYTE_GET (eaux->vna_name);
10600 aux.vna_next = BYTE_GET (eaux->vna_next);
10601
10602 if (VALID_DYNAMIC_NAME (aux.vna_name))
10603 printf (_(" %#06lx: Name: %s"),
10604 isum, GET_DYNAMIC_NAME (aux.vna_name));
10605 else
10606 printf (_(" %#06lx: Name index: %lx"),
10607 isum, aux.vna_name);
10608
10609 printf (_(" Flags: %s Version: %d\n"),
10610 get_ver_flags (aux.vna_flags), aux.vna_other);
10611
10612 if (aux.vna_next < sizeof (*eaux)
10613 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10614 {
10615 warn (_("Invalid vna_next field of %lx\n"),
10616 aux.vna_next);
10617 j = ent.vn_cnt;
10618 break;
10619 }
10620 /* Check for overflow. */
10621 if (aux.vna_next > (size_t) (endbuf - vstart))
10622 break;
10623 isum += aux.vna_next;
10624 vstart += aux.vna_next;
10625 }
10626
10627 if (j < ent.vn_cnt)
10628 warn (_("Missing Version Needs auxillary information\n"));
10629
10630 if (ent.vn_next < sizeof (*entry)
10631 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10632 {
10633 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10634 cnt = section->sh_info;
10635 break;
10636 }
10637 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10638 break;
10639 idx += ent.vn_next;
10640 }
10641
10642 if (cnt < section->sh_info)
10643 warn (_("Missing Version Needs information\n"));
10644
10645 free (eneed);
10646 }
10647 break;
10648
10649 case SHT_GNU_versym:
10650 {
10651 Elf_Internal_Shdr * link_section;
10652 size_t total;
10653 unsigned int cnt;
10654 unsigned char * edata;
10655 unsigned short * data;
10656 char * strtab;
10657 Elf_Internal_Sym * symbols;
10658 Elf_Internal_Shdr * string_sec;
10659 unsigned long num_syms;
10660 long off;
10661
10662 if (section->sh_link >= filedata->file_header.e_shnum)
10663 break;
10664
10665 link_section = filedata->section_headers + section->sh_link;
10666 total = section->sh_size / sizeof (Elf_External_Versym);
10667
10668 if (link_section->sh_link >= filedata->file_header.e_shnum)
10669 break;
10670
10671 found = TRUE;
10672
10673 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10674 if (symbols == NULL)
10675 break;
10676
10677 string_sec = filedata->section_headers + link_section->sh_link;
10678
10679 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10680 string_sec->sh_size,
10681 _("version string table"));
10682 if (!strtab)
10683 {
10684 free (symbols);
10685 break;
10686 }
10687
10688 printf (ngettext ("\nVersion symbols section '%s' "
10689 "contains %lu entry:\n",
10690 "\nVersion symbols section '%s' "
10691 "contains %lu entries:\n",
10692 total),
10693 printable_section_name (filedata, section), (unsigned long) total);
10694
10695 printf (_(" Addr: "));
10696 printf_vma (section->sh_addr);
10697 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10698 (unsigned long) section->sh_offset, section->sh_link,
10699 printable_section_name (filedata, link_section));
10700
10701 off = offset_from_vma (filedata,
10702 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10703 total * sizeof (short));
10704 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10705 sizeof (short),
10706 _("version symbol data"));
10707 if (!edata)
10708 {
10709 free (strtab);
10710 free (symbols);
10711 break;
10712 }
10713
10714 data = (short unsigned int *) cmalloc (total, sizeof (short));
10715
10716 for (cnt = total; cnt --;)
10717 data[cnt] = byte_get (edata + cnt * sizeof (short),
10718 sizeof (short));
10719
10720 free (edata);
10721
10722 for (cnt = 0; cnt < total; cnt += 4)
10723 {
10724 int j, nn;
10725 char *name;
10726 char *invalid = _("*invalid*");
10727
10728 printf (" %03x:", cnt);
10729
10730 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10731 switch (data[cnt + j])
10732 {
10733 case 0:
10734 fputs (_(" 0 (*local*) "), stdout);
10735 break;
10736
10737 case 1:
10738 fputs (_(" 1 (*global*) "), stdout);
10739 break;
10740
10741 default:
10742 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10743 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10744
10745 /* If this index value is greater than the size of the symbols
10746 array, break to avoid an out-of-bounds read. */
10747 if ((unsigned long)(cnt + j) >= num_syms)
10748 {
10749 warn (_("invalid index into symbol array\n"));
10750 break;
10751 }
10752
10753 name = NULL;
10754 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10755 {
10756 Elf_Internal_Verneed ivn;
10757 unsigned long offset;
10758
10759 offset = offset_from_vma
10760 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10761 sizeof (Elf_External_Verneed));
10762
10763 do
10764 {
10765 Elf_Internal_Vernaux ivna;
10766 Elf_External_Verneed evn;
10767 Elf_External_Vernaux evna;
10768 unsigned long a_off;
10769
10770 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10771 _("version need")) == NULL)
10772 break;
10773
10774 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10775 ivn.vn_next = BYTE_GET (evn.vn_next);
10776
10777 a_off = offset + ivn.vn_aux;
10778
10779 do
10780 {
10781 if (get_data (&evna, filedata, a_off, sizeof (evna),
10782 1, _("version need aux (2)")) == NULL)
10783 {
10784 ivna.vna_next = 0;
10785 ivna.vna_other = 0;
10786 }
10787 else
10788 {
10789 ivna.vna_next = BYTE_GET (evna.vna_next);
10790 ivna.vna_other = BYTE_GET (evna.vna_other);
10791 }
10792
10793 a_off += ivna.vna_next;
10794 }
10795 while (ivna.vna_other != data[cnt + j]
10796 && ivna.vna_next != 0);
10797
10798 if (ivna.vna_other == data[cnt + j])
10799 {
10800 ivna.vna_name = BYTE_GET (evna.vna_name);
10801
10802 if (ivna.vna_name >= string_sec->sh_size)
10803 name = invalid;
10804 else
10805 name = strtab + ivna.vna_name;
10806 break;
10807 }
10808
10809 offset += ivn.vn_next;
10810 }
10811 while (ivn.vn_next);
10812 }
10813
10814 if (data[cnt + j] != 0x8001
10815 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10816 {
10817 Elf_Internal_Verdef ivd;
10818 Elf_External_Verdef evd;
10819 unsigned long offset;
10820
10821 offset = offset_from_vma
10822 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10823 sizeof evd);
10824
10825 do
10826 {
10827 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10828 _("version def")) == NULL)
10829 {
10830 ivd.vd_next = 0;
10831 /* PR 17531: file: 046-1082287-0.004. */
10832 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10833 break;
10834 }
10835 else
10836 {
10837 ivd.vd_next = BYTE_GET (evd.vd_next);
10838 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10839 }
10840
10841 offset += ivd.vd_next;
10842 }
10843 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10844 && ivd.vd_next != 0);
10845
10846 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10847 {
10848 Elf_External_Verdaux evda;
10849 Elf_Internal_Verdaux ivda;
10850
10851 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10852
10853 if (get_data (&evda, filedata,
10854 offset - ivd.vd_next + ivd.vd_aux,
10855 sizeof (evda), 1,
10856 _("version def aux")) == NULL)
10857 break;
10858
10859 ivda.vda_name = BYTE_GET (evda.vda_name);
10860
10861 if (ivda.vda_name >= string_sec->sh_size)
10862 name = invalid;
10863 else if (name != NULL && name != invalid)
10864 name = _("*both*");
10865 else
10866 name = strtab + ivda.vda_name;
10867 }
10868 }
10869 if (name != NULL)
10870 nn += printf ("(%s%-*s",
10871 name,
10872 12 - (int) strlen (name),
10873 ")");
10874
10875 if (nn < 18)
10876 printf ("%*c", 18 - nn, ' ');
10877 }
10878
10879 putchar ('\n');
10880 }
10881
10882 free (data);
10883 free (strtab);
10884 free (symbols);
10885 }
10886 break;
10887
10888 default:
10889 break;
10890 }
10891 }
10892
10893 if (! found)
10894 printf (_("\nNo version information found in this file.\n"));
10895
10896 return TRUE;
10897}
10898
10899static const char *
10900get_symbol_binding (Filedata * filedata, unsigned int binding)
10901{
10902 static char buff[32];
10903
10904 switch (binding)
10905 {
10906 case STB_LOCAL: return "LOCAL";
10907 case STB_GLOBAL: return "GLOBAL";
10908 case STB_WEAK: return "WEAK";
10909 default:
10910 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10911 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10912 binding);
10913 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10914 {
10915 if (binding == STB_GNU_UNIQUE
10916 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10917 /* GNU is still using the default value 0. */
10918 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10919 return "UNIQUE";
10920 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10921 }
10922 else
10923 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10924 return buff;
10925 }
10926}
10927
10928static const char *
10929get_symbol_type (Filedata * filedata, unsigned int type)
10930{
10931 static char buff[32];
10932
10933 switch (type)
10934 {
10935 case STT_NOTYPE: return "NOTYPE";
10936 case STT_OBJECT: return "OBJECT";
10937 case STT_FUNC: return "FUNC";
10938 case STT_SECTION: return "SECTION";
10939 case STT_FILE: return "FILE";
10940 case STT_COMMON: return "COMMON";
10941 case STT_TLS: return "TLS";
10942 case STT_RELC: return "RELC";
10943 case STT_SRELC: return "SRELC";
10944 default:
10945 if (type >= STT_LOPROC && type <= STT_HIPROC)
10946 {
10947 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10948 return "THUMB_FUNC";
10949
10950 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10951 return "REGISTER";
10952
10953 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10954 return "PARISC_MILLI";
10955
10956 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10957 }
10958 else if (type >= STT_LOOS && type <= STT_HIOS)
10959 {
10960 if (filedata->file_header.e_machine == EM_PARISC)
10961 {
10962 if (type == STT_HP_OPAQUE)
10963 return "HP_OPAQUE";
10964 if (type == STT_HP_STUB)
10965 return "HP_STUB";
10966 }
10967
10968 if (type == STT_GNU_IFUNC
10969 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10970 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10971 /* GNU is still using the default value 0. */
10972 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10973 return "IFUNC";
10974
10975 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10976 }
10977 else
10978 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10979 return buff;
10980 }
10981}
10982
10983static const char *
10984get_symbol_visibility (unsigned int visibility)
10985{
10986 switch (visibility)
10987 {
10988 case STV_DEFAULT: return "DEFAULT";
10989 case STV_INTERNAL: return "INTERNAL";
10990 case STV_HIDDEN: return "HIDDEN";
10991 case STV_PROTECTED: return "PROTECTED";
10992 default:
10993 error (_("Unrecognized visibility value: %u"), visibility);
10994 return _("<unknown>");
10995 }
10996}
10997
10998static const char *
10999get_solaris_symbol_visibility (unsigned int visibility)
11000{
11001 switch (visibility)
11002 {
11003 case 4: return "EXPORTED";
11004 case 5: return "SINGLETON";
11005 case 6: return "ELIMINATE";
11006 default: return get_symbol_visibility (visibility);
11007 }
11008}
11009
11010static const char *
11011get_mips_symbol_other (unsigned int other)
11012{
11013 switch (other)
11014 {
11015 case STO_OPTIONAL: return "OPTIONAL";
11016 case STO_MIPS_PLT: return "MIPS PLT";
11017 case STO_MIPS_PIC: return "MIPS PIC";
11018 case STO_MICROMIPS: return "MICROMIPS";
11019 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11020 case STO_MIPS16: return "MIPS16";
11021 default: return NULL;
11022 }
11023}
11024
11025static const char *
11026get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11027{
11028 if (is_ia64_vms (filedata))
11029 {
11030 static char res[32];
11031
11032 res[0] = 0;
11033
11034 /* Function types is for images and .STB files only. */
11035 switch (filedata->file_header.e_type)
11036 {
11037 case ET_DYN:
11038 case ET_EXEC:
11039 switch (VMS_ST_FUNC_TYPE (other))
11040 {
11041 case VMS_SFT_CODE_ADDR:
11042 strcat (res, " CA");
11043 break;
11044 case VMS_SFT_SYMV_IDX:
11045 strcat (res, " VEC");
11046 break;
11047 case VMS_SFT_FD:
11048 strcat (res, " FD");
11049 break;
11050 case VMS_SFT_RESERVE:
11051 strcat (res, " RSV");
11052 break;
11053 default:
11054 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11055 VMS_ST_FUNC_TYPE (other));
11056 strcat (res, " <unknown>");
11057 break;
11058 }
11059 break;
11060 default:
11061 break;
11062 }
11063 switch (VMS_ST_LINKAGE (other))
11064 {
11065 case VMS_STL_IGNORE:
11066 strcat (res, " IGN");
11067 break;
11068 case VMS_STL_RESERVE:
11069 strcat (res, " RSV");
11070 break;
11071 case VMS_STL_STD:
11072 strcat (res, " STD");
11073 break;
11074 case VMS_STL_LNK:
11075 strcat (res, " LNK");
11076 break;
11077 default:
11078 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11079 VMS_ST_LINKAGE (other));
11080 strcat (res, " <unknown>");
11081 break;
11082 }
11083
11084 if (res[0] != 0)
11085 return res + 1;
11086 else
11087 return res;
11088 }
11089 return NULL;
11090}
11091
11092static const char *
11093get_ppc64_symbol_other (unsigned int other)
11094{
11095 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11096 return NULL;
11097
11098 other >>= STO_PPC64_LOCAL_BIT;
11099 if (other <= 6)
11100 {
11101 static char buf[32];
11102 if (other >= 2)
11103 other = ppc64_decode_local_entry (other);
11104 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11105 return buf;
11106 }
11107 return NULL;
11108}
11109
11110static const char *
11111get_symbol_other (Filedata * filedata, unsigned int other)
11112{
11113 const char * result = NULL;
11114 static char buff [32];
11115
11116 if (other == 0)
11117 return "";
11118
11119 switch (filedata->file_header.e_machine)
11120 {
11121 case EM_MIPS:
11122 result = get_mips_symbol_other (other);
11123 break;
11124 case EM_IA_64:
11125 result = get_ia64_symbol_other (filedata, other);
11126 break;
11127 case EM_PPC64:
11128 result = get_ppc64_symbol_other (other);
11129 break;
11130 default:
11131 result = NULL;
11132 break;
11133 }
11134
11135 if (result)
11136 return result;
11137
11138 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11139 return buff;
11140}
11141
11142static const char *
11143get_symbol_index_type (Filedata * filedata, unsigned int type)
11144{
11145 static char buff[32];
11146
11147 switch (type)
11148 {
11149 case SHN_UNDEF: return "UND";
11150 case SHN_ABS: return "ABS";
11151 case SHN_COMMON: return "COM";
11152 default:
11153 if (type == SHN_IA_64_ANSI_COMMON
11154 && filedata->file_header.e_machine == EM_IA_64
11155 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11156 return "ANSI_COM";
11157 else if ((filedata->file_header.e_machine == EM_X86_64
11158 || filedata->file_header.e_machine == EM_L1OM
11159 || filedata->file_header.e_machine == EM_K1OM)
11160 && type == SHN_X86_64_LCOMMON)
11161 return "LARGE_COM";
11162 else if ((type == SHN_MIPS_SCOMMON
11163 && filedata->file_header.e_machine == EM_MIPS)
11164 || (type == SHN_TIC6X_SCOMMON
11165 && filedata->file_header.e_machine == EM_TI_C6000))
11166 return "SCOM";
11167 else if (type == SHN_MIPS_SUNDEFINED
11168 && filedata->file_header.e_machine == EM_MIPS)
11169 return "SUND";
11170 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11171 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11172 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11173 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11174 else if (type >= SHN_LORESERVE)
11175 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11176 else if (type >= filedata->file_header.e_shnum)
11177 sprintf (buff, _("bad section index[%3d]"), type);
11178 else
11179 sprintf (buff, "%3d", type);
11180 break;
11181 }
11182
11183 return buff;
11184}
11185
11186static bfd_vma *
11187get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11188{
11189 unsigned char * e_data;
11190 bfd_vma * i_data;
11191
11192 /* If the size_t type is smaller than the bfd_size_type, eg because
11193 you are building a 32-bit tool on a 64-bit host, then make sure
11194 that when (number) is cast to (size_t) no information is lost. */
11195 if (sizeof (size_t) < sizeof (bfd_size_type)
11196 && (bfd_size_type) ((size_t) number) != number)
11197 {
11198 error (_("Size truncation prevents reading %s elements of size %u\n"),
11199 bfd_vmatoa ("u", number), ent_size);
11200 return NULL;
11201 }
11202
11203 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11204 attempting to allocate memory when the read is bound to fail. */
11205 if (ent_size * number > filedata->file_size)
11206 {
11207 error (_("Invalid number of dynamic entries: %s\n"),
11208 bfd_vmatoa ("u", number));
11209 return NULL;
11210 }
11211
11212 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11213 if (e_data == NULL)
11214 {
11215 error (_("Out of memory reading %s dynamic entries\n"),
11216 bfd_vmatoa ("u", number));
11217 return NULL;
11218 }
11219
11220 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11221 {
11222 error (_("Unable to read in %s bytes of dynamic data\n"),
11223 bfd_vmatoa ("u", number * ent_size));
11224 free (e_data);
11225 return NULL;
11226 }
11227
11228 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11229 if (i_data == NULL)
11230 {
11231 error (_("Out of memory allocating space for %s dynamic entries\n"),
11232 bfd_vmatoa ("u", number));
11233 free (e_data);
11234 return NULL;
11235 }
11236
11237 while (number--)
11238 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11239
11240 free (e_data);
11241
11242 return i_data;
11243}
11244
11245static void
11246print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11247{
11248 Elf_Internal_Sym * psym;
11249 int n;
11250
11251 n = print_vma (si, DEC_5);
11252 if (n < 5)
11253 fputs (&" "[n], stdout);
11254 printf (" %3lu: ", hn);
11255
11256 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11257 {
11258 printf (_("<No info available for dynamic symbol number %lu>\n"),
11259 (unsigned long) si);
11260 return;
11261 }
11262
11263 psym = dynamic_symbols + si;
11264 print_vma (psym->st_value, LONG_HEX);
11265 putchar (' ');
11266 print_vma (psym->st_size, DEC_5);
11267
11268 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11269 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11270
11271 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11272 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11273 else
11274 {
11275 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11276
11277 printf (" %-7s", get_symbol_visibility (vis));
11278 /* Check to see if any other bits in the st_other field are set.
11279 Note - displaying this information disrupts the layout of the
11280 table being generated, but for the moment this case is very
11281 rare. */
11282 if (psym->st_other ^ vis)
11283 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11284 }
11285
11286 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11287 if (VALID_DYNAMIC_NAME (psym->st_name))
11288 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11289 else
11290 printf (_(" <corrupt: %14ld>"), psym->st_name);
11291 putchar ('\n');
11292}
11293
11294static const char *
11295get_symbol_version_string (Filedata * filedata,
11296 bfd_boolean is_dynsym,
11297 const char * strtab,
11298 unsigned long int strtab_size,
11299 unsigned int si,
11300 Elf_Internal_Sym * psym,
11301 enum versioned_symbol_info * sym_info,
11302 unsigned short * vna_other)
11303{
11304 unsigned char data[2];
11305 unsigned short vers_data;
11306 unsigned long offset;
11307 unsigned short max_vd_ndx;
11308
11309 if (!is_dynsym
11310 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11311 return NULL;
11312
11313 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11314 sizeof data + si * sizeof (vers_data));
11315
11316 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11317 sizeof (data), 1, _("version data")) == NULL)
11318 return NULL;
11319
11320 vers_data = byte_get (data, 2);
11321
11322 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11323 return NULL;
11324
11325 max_vd_ndx = 0;
11326
11327 /* Usually we'd only see verdef for defined symbols, and verneed for
11328 undefined symbols. However, symbols defined by the linker in
11329 .dynbss for variables copied from a shared library in order to
11330 avoid text relocations are defined yet have verneed. We could
11331 use a heuristic to detect the special case, for example, check
11332 for verneed first on symbols defined in SHT_NOBITS sections, but
11333 it is simpler and more reliable to just look for both verdef and
11334 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11335
11336 if (psym->st_shndx != SHN_UNDEF
11337 && vers_data != 0x8001
11338 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11339 {
11340 Elf_Internal_Verdef ivd;
11341 Elf_Internal_Verdaux ivda;
11342 Elf_External_Verdaux evda;
11343 unsigned long off;
11344
11345 off = offset_from_vma (filedata,
11346 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11347 sizeof (Elf_External_Verdef));
11348
11349 do
11350 {
11351 Elf_External_Verdef evd;
11352
11353 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11354 _("version def")) == NULL)
11355 {
11356 ivd.vd_ndx = 0;
11357 ivd.vd_aux = 0;
11358 ivd.vd_next = 0;
11359 ivd.vd_flags = 0;
11360 }
11361 else
11362 {
11363 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11364 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11365 ivd.vd_next = BYTE_GET (evd.vd_next);
11366 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11367 }
11368
11369 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11370 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11371
11372 off += ivd.vd_next;
11373 }
11374 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11375
11376 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11377 {
11378 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11379 return NULL;
11380
11381 off -= ivd.vd_next;
11382 off += ivd.vd_aux;
11383
11384 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11385 _("version def aux")) != NULL)
11386 {
11387 ivda.vda_name = BYTE_GET (evda.vda_name);
11388
11389 if (psym->st_name != ivda.vda_name)
11390 {
11391 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11392 ? symbol_hidden : symbol_public);
11393 return (ivda.vda_name < strtab_size
11394 ? strtab + ivda.vda_name : _("<corrupt>"));
11395 }
11396 }
11397 }
11398 }
11399
11400 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11401 {
11402 Elf_External_Verneed evn;
11403 Elf_Internal_Verneed ivn;
11404 Elf_Internal_Vernaux ivna;
11405
11406 offset = offset_from_vma (filedata,
11407 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11408 sizeof evn);
11409 do
11410 {
11411 unsigned long vna_off;
11412
11413 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11414 _("version need")) == NULL)
11415 {
11416 ivna.vna_next = 0;
11417 ivna.vna_other = 0;
11418 ivna.vna_name = 0;
11419 break;
11420 }
11421
11422 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11423 ivn.vn_next = BYTE_GET (evn.vn_next);
11424
11425 vna_off = offset + ivn.vn_aux;
11426
11427 do
11428 {
11429 Elf_External_Vernaux evna;
11430
11431 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11432 _("version need aux (3)")) == NULL)
11433 {
11434 ivna.vna_next = 0;
11435 ivna.vna_other = 0;
11436 ivna.vna_name = 0;
11437 }
11438 else
11439 {
11440 ivna.vna_other = BYTE_GET (evna.vna_other);
11441 ivna.vna_next = BYTE_GET (evna.vna_next);
11442 ivna.vna_name = BYTE_GET (evna.vna_name);
11443 }
11444
11445 vna_off += ivna.vna_next;
11446 }
11447 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11448
11449 if (ivna.vna_other == vers_data)
11450 break;
11451
11452 offset += ivn.vn_next;
11453 }
11454 while (ivn.vn_next != 0);
11455
11456 if (ivna.vna_other == vers_data)
11457 {
11458 *sym_info = symbol_undefined;
11459 *vna_other = ivna.vna_other;
11460 return (ivna.vna_name < strtab_size
11461 ? strtab + ivna.vna_name : _("<corrupt>"));
11462 }
11463 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11464 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11465 return _("<corrupt>");
11466 }
11467 return NULL;
11468}
11469
11470/* Dump the symbol table. */
11471static bfd_boolean
11472process_symbol_table (Filedata * filedata)
11473{
11474 Elf_Internal_Shdr * section;
11475 bfd_size_type nbuckets = 0;
11476 bfd_size_type nchains = 0;
11477 bfd_vma * buckets = NULL;
11478 bfd_vma * chains = NULL;
11479 bfd_vma ngnubuckets = 0;
11480 bfd_vma * gnubuckets = NULL;
11481 bfd_vma * gnuchains = NULL;
11482 bfd_vma gnusymidx = 0;
11483 bfd_size_type ngnuchains = 0;
11484
11485 if (!do_syms && !do_dyn_syms && !do_histogram)
11486 return TRUE;
11487
11488 if (dynamic_info[DT_HASH]
11489 && (do_histogram
11490 || (do_using_dynamic
11491 && !do_dyn_syms
11492 && dynamic_strings != NULL)))
11493 {
11494 unsigned char nb[8];
11495 unsigned char nc[8];
11496 unsigned int hash_ent_size = 4;
11497
11498 if ((filedata->file_header.e_machine == EM_ALPHA
11499 || filedata->file_header.e_machine == EM_S390
11500 || filedata->file_header.e_machine == EM_S390_OLD)
11501 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11502 hash_ent_size = 8;
11503
11504 if (fseek (filedata->handle,
11505 (archive_file_offset
11506 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11507 sizeof nb + sizeof nc)),
11508 SEEK_SET))
11509 {
11510 error (_("Unable to seek to start of dynamic information\n"));
11511 goto no_hash;
11512 }
11513
11514 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11515 {
11516 error (_("Failed to read in number of buckets\n"));
11517 goto no_hash;
11518 }
11519
11520 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11521 {
11522 error (_("Failed to read in number of chains\n"));
11523 goto no_hash;
11524 }
11525
11526 nbuckets = byte_get (nb, hash_ent_size);
11527 nchains = byte_get (nc, hash_ent_size);
11528
11529 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11530 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11531
11532 no_hash:
11533 if (buckets == NULL || chains == NULL)
11534 {
11535 if (do_using_dynamic)
11536 return FALSE;
11537 free (buckets);
11538 free (chains);
11539 buckets = NULL;
11540 chains = NULL;
11541 nbuckets = 0;
11542 nchains = 0;
11543 }
11544 }
11545
11546 if (dynamic_info_DT_GNU_HASH
11547 && (do_histogram
11548 || (do_using_dynamic
11549 && !do_dyn_syms
11550 && dynamic_strings != NULL)))
11551 {
11552 unsigned char nb[16];
11553 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11554 bfd_vma buckets_vma;
11555
11556 if (fseek (filedata->handle,
11557 (archive_file_offset
11558 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11559 sizeof nb)),
11560 SEEK_SET))
11561 {
11562 error (_("Unable to seek to start of dynamic information\n"));
11563 goto no_gnu_hash;
11564 }
11565
11566 if (fread (nb, 16, 1, filedata->handle) != 1)
11567 {
11568 error (_("Failed to read in number of buckets\n"));
11569 goto no_gnu_hash;
11570 }
11571
11572 ngnubuckets = byte_get (nb, 4);
11573 gnusymidx = byte_get (nb + 4, 4);
11574 bitmaskwords = byte_get (nb + 8, 4);
11575 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11576 if (is_32bit_elf)
11577 buckets_vma += bitmaskwords * 4;
11578 else
11579 buckets_vma += bitmaskwords * 8;
11580
11581 if (fseek (filedata->handle,
11582 (archive_file_offset
11583 + offset_from_vma (filedata, buckets_vma, 4)),
11584 SEEK_SET))
11585 {
11586 error (_("Unable to seek to start of dynamic information\n"));
11587 goto no_gnu_hash;
11588 }
11589
11590 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11591
11592 if (gnubuckets == NULL)
11593 goto no_gnu_hash;
11594
11595 for (i = 0; i < ngnubuckets; i++)
11596 if (gnubuckets[i] != 0)
11597 {
11598 if (gnubuckets[i] < gnusymidx)
11599 return FALSE;
11600
11601 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11602 maxchain = gnubuckets[i];
11603 }
11604
11605 if (maxchain == 0xffffffff)
11606 goto no_gnu_hash;
11607
11608 maxchain -= gnusymidx;
11609
11610 if (fseek (filedata->handle,
11611 (archive_file_offset
11612 + offset_from_vma (filedata, buckets_vma
11613 + 4 * (ngnubuckets + maxchain), 4)),
11614 SEEK_SET))
11615 {
11616 error (_("Unable to seek to start of dynamic information\n"));
11617 goto no_gnu_hash;
11618 }
11619
11620 do
11621 {
11622 if (fread (nb, 4, 1, filedata->handle) != 1)
11623 {
11624 error (_("Failed to determine last chain length\n"));
11625 goto no_gnu_hash;
11626 }
11627
11628 if (maxchain + 1 == 0)
11629 goto no_gnu_hash;
11630
11631 ++maxchain;
11632 }
11633 while ((byte_get (nb, 4) & 1) == 0);
11634
11635 if (fseek (filedata->handle,
11636 (archive_file_offset
11637 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11638 SEEK_SET))
11639 {
11640 error (_("Unable to seek to start of dynamic information\n"));
11641 goto no_gnu_hash;
11642 }
11643
11644 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11645 ngnuchains = maxchain;
11646
11647 no_gnu_hash:
11648 if (gnuchains == NULL)
11649 {
11650 free (gnubuckets);
11651 gnubuckets = NULL;
11652 ngnubuckets = 0;
11653 if (do_using_dynamic)
11654 return FALSE;
11655 }
11656 }
11657
11658 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11659 && do_syms
11660 && do_using_dynamic
11661 && dynamic_strings != NULL
11662 && dynamic_symbols != NULL)
11663 {
11664 unsigned long hn;
11665
11666 if (dynamic_info[DT_HASH])
11667 {
11668 bfd_vma si;
11669 char *visited;
11670
11671 printf (_("\nSymbol table for image:\n"));
11672 if (is_32bit_elf)
11673 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11674 else
11675 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11676
11677 visited = xcmalloc (nchains, 1);
11678 memset (visited, 0, nchains);
11679 for (hn = 0; hn < nbuckets; hn++)
11680 {
11681 for (si = buckets[hn]; si > 0; si = chains[si])
11682 {
11683 print_dynamic_symbol (filedata, si, hn);
11684 if (si >= nchains || visited[si])
11685 {
11686 error (_("histogram chain is corrupt\n"));
11687 break;
11688 }
11689 visited[si] = 1;
11690 }
11691 }
11692 free (visited);
11693 }
11694
11695 if (dynamic_info_DT_GNU_HASH)
11696 {
11697 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11698 if (is_32bit_elf)
11699 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11700 else
11701 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11702
11703 for (hn = 0; hn < ngnubuckets; ++hn)
11704 if (gnubuckets[hn] != 0)
11705 {
11706 bfd_vma si = gnubuckets[hn];
11707 bfd_vma off = si - gnusymidx;
11708
11709 do
11710 {
11711 print_dynamic_symbol (filedata, si, hn);
11712 si++;
11713 }
11714 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11715 }
11716 }
11717 }
11718 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11719 && filedata->section_headers != NULL)
11720 {
11721 unsigned int i;
11722
11723 for (i = 0, section = filedata->section_headers;
11724 i < filedata->file_header.e_shnum;
11725 i++, section++)
11726 {
11727 unsigned int si;
11728 char * strtab = NULL;
11729 unsigned long int strtab_size = 0;
11730 Elf_Internal_Sym * symtab;
11731 Elf_Internal_Sym * psym;
11732 unsigned long num_syms;
11733
11734 if ((section->sh_type != SHT_SYMTAB
11735 && section->sh_type != SHT_DYNSYM)
11736 || (!do_syms
11737 && section->sh_type == SHT_SYMTAB))
11738 continue;
11739
11740 if (section->sh_entsize == 0)
11741 {
11742 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11743 printable_section_name (filedata, section));
11744 continue;
11745 }
11746
11747 num_syms = section->sh_size / section->sh_entsize;
11748 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11749 "\nSymbol table '%s' contains %lu entries:\n",
11750 num_syms),
11751 printable_section_name (filedata, section),
11752 num_syms);
11753
11754 if (is_32bit_elf)
11755 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11756 else
11757 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11758
11759 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11760 if (symtab == NULL)
11761 continue;
11762
11763 if (section->sh_link == filedata->file_header.e_shstrndx)
11764 {
11765 strtab = filedata->string_table;
11766 strtab_size = filedata->string_table_length;
11767 }
11768 else if (section->sh_link < filedata->file_header.e_shnum)
11769 {
11770 Elf_Internal_Shdr * string_sec;
11771
11772 string_sec = filedata->section_headers + section->sh_link;
11773
11774 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11775 1, string_sec->sh_size,
11776 _("string table"));
11777 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11778 }
11779
11780 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11781 {
11782 const char *version_string;
11783 enum versioned_symbol_info sym_info;
11784 unsigned short vna_other;
11785
11786 printf ("%6d: ", si);
11787 print_vma (psym->st_value, LONG_HEX);
11788 putchar (' ');
11789 print_vma (psym->st_size, DEC_5);
11790 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11791 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11792 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11793 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11794 else
11795 {
11796 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11797
11798 printf (" %-7s", get_symbol_visibility (vis));
11799 /* Check to see if any other bits in the st_other field are set.
11800 Note - displaying this information disrupts the layout of the
11801 table being generated, but for the moment this case is very rare. */
11802 if (psym->st_other ^ vis)
11803 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11804 }
11805 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11806 print_symbol (25, psym->st_name < strtab_size
11807 ? strtab + psym->st_name : _("<corrupt>"));
11808
11809 version_string
11810 = get_symbol_version_string (filedata,
11811 section->sh_type == SHT_DYNSYM,
11812 strtab, strtab_size, si,
11813 psym, &sym_info, &vna_other);
11814 if (version_string)
11815 {
11816 if (sym_info == symbol_undefined)
11817 printf ("@%s (%d)", version_string, vna_other);
11818 else
11819 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11820 version_string);
11821 }
11822
11823 putchar ('\n');
11824
11825 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11826 && si >= section->sh_info
11827 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11828 && filedata->file_header.e_machine != EM_MIPS
11829 /* Solaris binaries have been found to violate this requirement as
11830 well. Not sure if this is a bug or an ABI requirement. */
11831 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11832 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11833 si, printable_section_name (filedata, section), section->sh_info);
11834 }
11835
11836 free (symtab);
11837 if (strtab != filedata->string_table)
11838 free (strtab);
11839 }
11840 }
11841 else if (do_syms)
11842 printf
11843 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11844
11845 if (do_histogram && buckets != NULL)
11846 {
11847 unsigned long * lengths;
11848 unsigned long * counts;
11849 unsigned long hn;
11850 bfd_vma si;
11851 unsigned long maxlength = 0;
11852 unsigned long nzero_counts = 0;
11853 unsigned long nsyms = 0;
11854 char *visited;
11855
11856 printf (ngettext ("\nHistogram for bucket list length "
11857 "(total of %lu bucket):\n",
11858 "\nHistogram for bucket list length "
11859 "(total of %lu buckets):\n",
11860 (unsigned long) nbuckets),
11861 (unsigned long) nbuckets);
11862
11863 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11864 if (lengths == NULL)
11865 {
11866 error (_("Out of memory allocating space for histogram buckets\n"));
11867 return FALSE;
11868 }
11869 visited = xcmalloc (nchains, 1);
11870 memset (visited, 0, nchains);
11871
11872 printf (_(" Length Number %% of total Coverage\n"));
11873 for (hn = 0; hn < nbuckets; ++hn)
11874 {
11875 for (si = buckets[hn]; si > 0; si = chains[si])
11876 {
11877 ++nsyms;
11878 if (maxlength < ++lengths[hn])
11879 ++maxlength;
11880 if (si >= nchains || visited[si])
11881 {
11882 error (_("histogram chain is corrupt\n"));
11883 break;
11884 }
11885 visited[si] = 1;
11886 }
11887 }
11888 free (visited);
11889
11890 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11891 if (counts == NULL)
11892 {
11893 free (lengths);
11894 error (_("Out of memory allocating space for histogram counts\n"));
11895 return FALSE;
11896 }
11897
11898 for (hn = 0; hn < nbuckets; ++hn)
11899 ++counts[lengths[hn]];
11900
11901 if (nbuckets > 0)
11902 {
11903 unsigned long i;
11904 printf (" 0 %-10lu (%5.1f%%)\n",
11905 counts[0], (counts[0] * 100.0) / nbuckets);
11906 for (i = 1; i <= maxlength; ++i)
11907 {
11908 nzero_counts += counts[i] * i;
11909 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11910 i, counts[i], (counts[i] * 100.0) / nbuckets,
11911 (nzero_counts * 100.0) / nsyms);
11912 }
11913 }
11914
11915 free (counts);
11916 free (lengths);
11917 }
11918
11919 if (buckets != NULL)
11920 {
11921 free (buckets);
11922 free (chains);
11923 }
11924
11925 if (do_histogram && gnubuckets != NULL)
11926 {
11927 unsigned long * lengths;
11928 unsigned long * counts;
11929 unsigned long hn;
11930 unsigned long maxlength = 0;
11931 unsigned long nzero_counts = 0;
11932 unsigned long nsyms = 0;
11933
11934 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11935 "(total of %lu bucket):\n",
11936 "\nHistogram for `.gnu.hash' bucket list length "
11937 "(total of %lu buckets):\n",
11938 (unsigned long) ngnubuckets),
11939 (unsigned long) ngnubuckets);
11940
11941 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11942 if (lengths == NULL)
11943 {
11944 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11945 return FALSE;
11946 }
11947
11948 printf (_(" Length Number %% of total Coverage\n"));
11949
11950 for (hn = 0; hn < ngnubuckets; ++hn)
11951 if (gnubuckets[hn] != 0)
11952 {
11953 bfd_vma off, length = 1;
11954
11955 for (off = gnubuckets[hn] - gnusymidx;
11956 /* PR 17531 file: 010-77222-0.004. */
11957 off < ngnuchains && (gnuchains[off] & 1) == 0;
11958 ++off)
11959 ++length;
11960 lengths[hn] = length;
11961 if (length > maxlength)
11962 maxlength = length;
11963 nsyms += length;
11964 }
11965
11966 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11967 if (counts == NULL)
11968 {
11969 free (lengths);
11970 error (_("Out of memory allocating space for gnu histogram counts\n"));
11971 return FALSE;
11972 }
11973
11974 for (hn = 0; hn < ngnubuckets; ++hn)
11975 ++counts[lengths[hn]];
11976
11977 if (ngnubuckets > 0)
11978 {
11979 unsigned long j;
11980 printf (" 0 %-10lu (%5.1f%%)\n",
11981 counts[0], (counts[0] * 100.0) / ngnubuckets);
11982 for (j = 1; j <= maxlength; ++j)
11983 {
11984 nzero_counts += counts[j] * j;
11985 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11986 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11987 (nzero_counts * 100.0) / nsyms);
11988 }
11989 }
11990
11991 free (counts);
11992 free (lengths);
11993 free (gnubuckets);
11994 free (gnuchains);
11995 }
11996
11997 return TRUE;
11998}
11999
12000static bfd_boolean
12001process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12002{
12003 unsigned int i;
12004
12005 if (dynamic_syminfo == NULL
12006 || !do_dynamic)
12007 /* No syminfo, this is ok. */
12008 return TRUE;
12009
12010 /* There better should be a dynamic symbol section. */
12011 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12012 return FALSE;
12013
12014 if (dynamic_addr)
12015 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12016 "contains %d entry:\n",
12017 "\nDynamic info segment at offset 0x%lx "
12018 "contains %d entries:\n",
12019 dynamic_syminfo_nent),
12020 dynamic_syminfo_offset, dynamic_syminfo_nent);
12021
12022 printf (_(" Num: Name BoundTo Flags\n"));
12023 for (i = 0; i < dynamic_syminfo_nent; ++i)
12024 {
12025 unsigned short int flags = dynamic_syminfo[i].si_flags;
12026
12027 printf ("%4d: ", i);
12028 if (i >= num_dynamic_syms)
12029 printf (_("<corrupt index>"));
12030 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12031 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12032 else
12033 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12034 putchar (' ');
12035
12036 switch (dynamic_syminfo[i].si_boundto)
12037 {
12038 case SYMINFO_BT_SELF:
12039 fputs ("SELF ", stdout);
12040 break;
12041 case SYMINFO_BT_PARENT:
12042 fputs ("PARENT ", stdout);
12043 break;
12044 default:
12045 if (dynamic_syminfo[i].si_boundto > 0
12046 && dynamic_syminfo[i].si_boundto < dynamic_nent
12047 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12048 {
12049 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12050 putchar (' ' );
12051 }
12052 else
12053 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12054 break;
12055 }
12056
12057 if (flags & SYMINFO_FLG_DIRECT)
12058 printf (" DIRECT");
12059 if (flags & SYMINFO_FLG_PASSTHRU)
12060 printf (" PASSTHRU");
12061 if (flags & SYMINFO_FLG_COPY)
12062 printf (" COPY");
12063 if (flags & SYMINFO_FLG_LAZYLOAD)
12064 printf (" LAZYLOAD");
12065
12066 puts ("");
12067 }
12068
12069 return TRUE;
12070}
12071
12072#define IN_RANGE(START,END,ADDR,OFF) \
12073 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12074
12075/* Check to see if the given reloc needs to be handled in a target specific
12076 manner. If so then process the reloc and return TRUE otherwise return
12077 FALSE.
12078
12079 If called with reloc == NULL, then this is a signal that reloc processing
12080 for the current section has finished, and any saved state should be
12081 discarded. */
12082
12083static bfd_boolean
12084target_specific_reloc_handling (Filedata * filedata,
12085 Elf_Internal_Rela * reloc,
12086 unsigned char * start,
12087 unsigned char * end,
12088 Elf_Internal_Sym * symtab,
12089 unsigned long num_syms)
12090{
12091 unsigned int reloc_type = 0;
12092 unsigned long sym_index = 0;
12093
12094 if (reloc)
12095 {
12096 reloc_type = get_reloc_type (filedata, reloc->r_info);
12097 sym_index = get_reloc_symindex (reloc->r_info);
12098 }
12099
12100 switch (filedata->file_header.e_machine)
12101 {
12102 case EM_MSP430:
12103 case EM_MSP430_OLD:
12104 {
12105 static Elf_Internal_Sym * saved_sym = NULL;
12106
12107 if (reloc == NULL)
12108 {
12109 saved_sym = NULL;
12110 return TRUE;
12111 }
12112
12113 switch (reloc_type)
12114 {
12115 case 10: /* R_MSP430_SYM_DIFF */
12116 if (uses_msp430x_relocs (filedata))
12117 break;
12118 /* Fall through. */
12119 case 21: /* R_MSP430X_SYM_DIFF */
12120 /* PR 21139. */
12121 if (sym_index >= num_syms)
12122 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12123 sym_index);
12124 else
12125 saved_sym = symtab + sym_index;
12126 return TRUE;
12127
12128 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12129 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12130 goto handle_sym_diff;
12131
12132 case 5: /* R_MSP430_16_BYTE */
12133 case 9: /* R_MSP430_8 */
12134 if (uses_msp430x_relocs (filedata))
12135 break;
12136 goto handle_sym_diff;
12137
12138 case 2: /* R_MSP430_ABS16 */
12139 case 15: /* R_MSP430X_ABS16 */
12140 if (! uses_msp430x_relocs (filedata))
12141 break;
12142 goto handle_sym_diff;
12143
12144 handle_sym_diff:
12145 if (saved_sym != NULL)
12146 {
12147 int reloc_size = reloc_type == 1 ? 4 : 2;
12148 bfd_vma value;
12149
12150 if (sym_index >= num_syms)
12151 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12152 sym_index);
12153 else
12154 {
12155 value = reloc->r_addend + (symtab[sym_index].st_value
12156 - saved_sym->st_value);
12157
12158 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12159 byte_put (start + reloc->r_offset, value, reloc_size);
12160 else
12161 /* PR 21137 */
12162 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12163 (long) reloc->r_offset);
12164 }
12165
12166 saved_sym = NULL;
12167 return TRUE;
12168 }
12169 break;
12170
12171 default:
12172 if (saved_sym != NULL)
12173 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12174 break;
12175 }
12176 break;
12177 }
12178
12179 case EM_MN10300:
12180 case EM_CYGNUS_MN10300:
12181 {
12182 static Elf_Internal_Sym * saved_sym = NULL;
12183
12184 if (reloc == NULL)
12185 {
12186 saved_sym = NULL;
12187 return TRUE;
12188 }
12189
12190 switch (reloc_type)
12191 {
12192 case 34: /* R_MN10300_ALIGN */
12193 return TRUE;
12194 case 33: /* R_MN10300_SYM_DIFF */
12195 if (sym_index >= num_syms)
12196 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12197 sym_index);
12198 else
12199 saved_sym = symtab + sym_index;
12200 return TRUE;
12201
12202 case 1: /* R_MN10300_32 */
12203 case 2: /* R_MN10300_16 */
12204 if (saved_sym != NULL)
12205 {
12206 int reloc_size = reloc_type == 1 ? 4 : 2;
12207 bfd_vma value;
12208
12209 if (sym_index >= num_syms)
12210 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12211 sym_index);
12212 else
12213 {
12214 value = reloc->r_addend + (symtab[sym_index].st_value
12215 - saved_sym->st_value);
12216
12217 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12218 byte_put (start + reloc->r_offset, value, reloc_size);
12219 else
12220 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12221 (long) reloc->r_offset);
12222 }
12223
12224 saved_sym = NULL;
12225 return TRUE;
12226 }
12227 break;
12228 default:
12229 if (saved_sym != NULL)
12230 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12231 break;
12232 }
12233 break;
12234 }
12235
12236 case EM_RL78:
12237 {
12238 static bfd_vma saved_sym1 = 0;
12239 static bfd_vma saved_sym2 = 0;
12240 static bfd_vma value;
12241
12242 if (reloc == NULL)
12243 {
12244 saved_sym1 = saved_sym2 = 0;
12245 return TRUE;
12246 }
12247
12248 switch (reloc_type)
12249 {
12250 case 0x80: /* R_RL78_SYM. */
12251 saved_sym1 = saved_sym2;
12252 if (sym_index >= num_syms)
12253 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12254 sym_index);
12255 else
12256 {
12257 saved_sym2 = symtab[sym_index].st_value;
12258 saved_sym2 += reloc->r_addend;
12259 }
12260 return TRUE;
12261
12262 case 0x83: /* R_RL78_OPsub. */
12263 value = saved_sym1 - saved_sym2;
12264 saved_sym2 = saved_sym1 = 0;
12265 return TRUE;
12266 break;
12267
12268 case 0x41: /* R_RL78_ABS32. */
12269 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12270 byte_put (start + reloc->r_offset, value, 4);
12271 else
12272 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12273 (long) reloc->r_offset);
12274 value = 0;
12275 return TRUE;
12276
12277 case 0x43: /* R_RL78_ABS16. */
12278 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12279 byte_put (start + reloc->r_offset, value, 2);
12280 else
12281 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12282 (long) reloc->r_offset);
12283 value = 0;
12284 return TRUE;
12285
12286 default:
12287 break;
12288 }
12289 break;
12290 }
12291 }
12292
12293 return FALSE;
12294}
12295
12296/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12297 DWARF debug sections. This is a target specific test. Note - we do not
12298 go through the whole including-target-headers-multiple-times route, (as
12299 we have already done with <elf/h8.h>) because this would become very
12300 messy and even then this function would have to contain target specific
12301 information (the names of the relocs instead of their numeric values).
12302 FIXME: This is not the correct way to solve this problem. The proper way
12303 is to have target specific reloc sizing and typing functions created by
12304 the reloc-macros.h header, in the same way that it already creates the
12305 reloc naming functions. */
12306
12307static bfd_boolean
12308is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12309{
12310 /* Please keep this table alpha-sorted for ease of visual lookup. */
12311 switch (filedata->file_header.e_machine)
12312 {
12313 case EM_386:
12314 case EM_IAMCU:
12315 return reloc_type == 1; /* R_386_32. */
12316 case EM_68K:
12317 return reloc_type == 1; /* R_68K_32. */
12318 case EM_860:
12319 return reloc_type == 1; /* R_860_32. */
12320 case EM_960:
12321 return reloc_type == 2; /* R_960_32. */
12322 case EM_AARCH64:
12323 return (reloc_type == 258
12324 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12325 case EM_ADAPTEVA_EPIPHANY:
12326 return reloc_type == 3;
12327 case EM_ALPHA:
12328 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12329 case EM_ARC:
12330 return reloc_type == 1; /* R_ARC_32. */
12331 case EM_ARC_COMPACT:
12332 case EM_ARC_COMPACT2:
12333 return reloc_type == 4; /* R_ARC_32. */
12334 case EM_ARM:
12335 return reloc_type == 2; /* R_ARM_ABS32 */
12336 case EM_AVR_OLD:
12337 case EM_AVR:
12338 return reloc_type == 1;
12339 case EM_BLACKFIN:
12340 return reloc_type == 0x12; /* R_byte4_data. */
12341 case EM_CRIS:
12342 return reloc_type == 3; /* R_CRIS_32. */
12343 case EM_CR16:
12344 return reloc_type == 3; /* R_CR16_NUM32. */
12345 case EM_CRX:
12346 return reloc_type == 15; /* R_CRX_NUM32. */
12347 case EM_CSKY:
12348 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12349 case EM_CYGNUS_FRV:
12350 return reloc_type == 1;
12351 case EM_CYGNUS_D10V:
12352 case EM_D10V:
12353 return reloc_type == 6; /* R_D10V_32. */
12354 case EM_CYGNUS_D30V:
12355 case EM_D30V:
12356 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12357 case EM_DLX:
12358 return reloc_type == 3; /* R_DLX_RELOC_32. */
12359 case EM_CYGNUS_FR30:
12360 case EM_FR30:
12361 return reloc_type == 3; /* R_FR30_32. */
12362 case EM_FT32:
12363 return reloc_type == 1; /* R_FT32_32. */
12364 case EM_H8S:
12365 case EM_H8_300:
12366 case EM_H8_300H:
12367 return reloc_type == 1; /* R_H8_DIR32. */
12368 case EM_IA_64:
12369 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12370 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12371 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12372 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12373 case EM_IP2K_OLD:
12374 case EM_IP2K:
12375 return reloc_type == 2; /* R_IP2K_32. */
12376 case EM_IQ2000:
12377 return reloc_type == 2; /* R_IQ2000_32. */
12378 case EM_LATTICEMICO32:
12379 return reloc_type == 3; /* R_LM32_32. */
12380 case EM_M32C_OLD:
12381 case EM_M32C:
12382 return reloc_type == 3; /* R_M32C_32. */
12383 case EM_M32R:
12384 return reloc_type == 34; /* R_M32R_32_RELA. */
12385 case EM_68HC11:
12386 case EM_68HC12:
12387 return reloc_type == 6; /* R_M68HC11_32. */
12388 case EM_S12Z:
12389 return reloc_type == 6; /* R_S12Z_EXT32. */
12390 case EM_MCORE:
12391 return reloc_type == 1; /* R_MCORE_ADDR32. */
12392 case EM_CYGNUS_MEP:
12393 return reloc_type == 4; /* R_MEP_32. */
12394 case EM_METAG:
12395 return reloc_type == 2; /* R_METAG_ADDR32. */
12396 case EM_MICROBLAZE:
12397 return reloc_type == 1; /* R_MICROBLAZE_32. */
12398 case EM_MIPS:
12399 return reloc_type == 2; /* R_MIPS_32. */
12400 case EM_MMIX:
12401 return reloc_type == 4; /* R_MMIX_32. */
12402 case EM_CYGNUS_MN10200:
12403 case EM_MN10200:
12404 return reloc_type == 1; /* R_MN10200_32. */
12405 case EM_CYGNUS_MN10300:
12406 case EM_MN10300:
12407 return reloc_type == 1; /* R_MN10300_32. */
12408 case EM_MOXIE:
12409 return reloc_type == 1; /* R_MOXIE_32. */
12410 case EM_MSP430_OLD:
12411 case EM_MSP430:
12412 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12413 case EM_MT:
12414 return reloc_type == 2; /* R_MT_32. */
12415 case EM_NDS32:
12416 return reloc_type == 20; /* R_NDS32_RELA. */
12417 case EM_ALTERA_NIOS2:
12418 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12419 case EM_NIOS32:
12420 return reloc_type == 1; /* R_NIOS_32. */
12421 case EM_OR1K:
12422 return reloc_type == 1; /* R_OR1K_32. */
12423 case EM_PARISC:
12424 return (reloc_type == 1 /* R_PARISC_DIR32. */
12425 || reloc_type == 2 /* R_PARISC_DIR21L. */
12426 || reloc_type == 41); /* R_PARISC_SECREL32. */
12427 case EM_PJ:
12428 case EM_PJ_OLD:
12429 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12430 case EM_PPC64:
12431 return reloc_type == 1; /* R_PPC64_ADDR32. */
12432 case EM_PPC:
12433 return reloc_type == 1; /* R_PPC_ADDR32. */
12434 case EM_TI_PRU:
12435 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12436 case EM_RISCV:
12437 return reloc_type == 1; /* R_RISCV_32. */
12438 case EM_RL78:
12439 return reloc_type == 1; /* R_RL78_DIR32. */
12440 case EM_RX:
12441 return reloc_type == 1; /* R_RX_DIR32. */
12442 case EM_S370:
12443 return reloc_type == 1; /* R_I370_ADDR31. */
12444 case EM_S390_OLD:
12445 case EM_S390:
12446 return reloc_type == 4; /* R_S390_32. */
12447 case EM_SCORE:
12448 return reloc_type == 8; /* R_SCORE_ABS32. */
12449 case EM_SH:
12450 return reloc_type == 1; /* R_SH_DIR32. */
12451 case EM_SPARC32PLUS:
12452 case EM_SPARCV9:
12453 case EM_SPARC:
12454 return reloc_type == 3 /* R_SPARC_32. */
12455 || reloc_type == 23; /* R_SPARC_UA32. */
12456 case EM_SPU:
12457 return reloc_type == 6; /* R_SPU_ADDR32 */
12458 case EM_TI_C6000:
12459 return reloc_type == 1; /* R_C6000_ABS32. */
12460 case EM_TILEGX:
12461 return reloc_type == 2; /* R_TILEGX_32. */
12462 case EM_TILEPRO:
12463 return reloc_type == 1; /* R_TILEPRO_32. */
12464 case EM_CYGNUS_V850:
12465 case EM_V850:
12466 return reloc_type == 6; /* R_V850_ABS32. */
12467 case EM_V800:
12468 return reloc_type == 0x33; /* R_V810_WORD. */
12469 case EM_VAX:
12470 return reloc_type == 1; /* R_VAX_32. */
12471 case EM_VISIUM:
12472 return reloc_type == 3; /* R_VISIUM_32. */
12473 case EM_WEBASSEMBLY:
12474 return reloc_type == 1; /* R_WASM32_32. */
12475 case EM_X86_64:
12476 case EM_L1OM:
12477 case EM_K1OM:
12478 return reloc_type == 10; /* R_X86_64_32. */
12479 case EM_XC16X:
12480 case EM_C166:
12481 return reloc_type == 3; /* R_XC16C_ABS_32. */
12482 case EM_XGATE:
12483 return reloc_type == 4; /* R_XGATE_32. */
12484 case EM_XSTORMY16:
12485 return reloc_type == 1; /* R_XSTROMY16_32. */
12486 case EM_XTENSA_OLD:
12487 case EM_XTENSA:
12488 return reloc_type == 1; /* R_XTENSA_32. */
12489 default:
12490 {
12491 static unsigned int prev_warn = 0;
12492
12493 /* Avoid repeating the same warning multiple times. */
12494 if (prev_warn != filedata->file_header.e_machine)
12495 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12496 filedata->file_header.e_machine);
12497 prev_warn = filedata->file_header.e_machine;
12498 return FALSE;
12499 }
12500 }
12501}
12502
12503/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12504 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12505
12506static bfd_boolean
12507is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12508{
12509 switch (filedata->file_header.e_machine)
12510 /* Please keep this table alpha-sorted for ease of visual lookup. */
12511 {
12512 case EM_386:
12513 case EM_IAMCU:
12514 return reloc_type == 2; /* R_386_PC32. */
12515 case EM_68K:
12516 return reloc_type == 4; /* R_68K_PC32. */
12517 case EM_AARCH64:
12518 return reloc_type == 261; /* R_AARCH64_PREL32 */
12519 case EM_ADAPTEVA_EPIPHANY:
12520 return reloc_type == 6;
12521 case EM_ALPHA:
12522 return reloc_type == 10; /* R_ALPHA_SREL32. */
12523 case EM_ARC_COMPACT:
12524 case EM_ARC_COMPACT2:
12525 return reloc_type == 49; /* R_ARC_32_PCREL. */
12526 case EM_ARM:
12527 return reloc_type == 3; /* R_ARM_REL32 */
12528 case EM_AVR_OLD:
12529 case EM_AVR:
12530 return reloc_type == 36; /* R_AVR_32_PCREL. */
12531 case EM_MICROBLAZE:
12532 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12533 case EM_OR1K:
12534 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12535 case EM_PARISC:
12536 return reloc_type == 9; /* R_PARISC_PCREL32. */
12537 case EM_PPC:
12538 return reloc_type == 26; /* R_PPC_REL32. */
12539 case EM_PPC64:
12540 return reloc_type == 26; /* R_PPC64_REL32. */
12541 case EM_S390_OLD:
12542 case EM_S390:
12543 return reloc_type == 5; /* R_390_PC32. */
12544 case EM_SH:
12545 return reloc_type == 2; /* R_SH_REL32. */
12546 case EM_SPARC32PLUS:
12547 case EM_SPARCV9:
12548 case EM_SPARC:
12549 return reloc_type == 6; /* R_SPARC_DISP32. */
12550 case EM_SPU:
12551 return reloc_type == 13; /* R_SPU_REL32. */
12552 case EM_TILEGX:
12553 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12554 case EM_TILEPRO:
12555 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12556 case EM_VISIUM:
12557 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12558 case EM_X86_64:
12559 case EM_L1OM:
12560 case EM_K1OM:
12561 return reloc_type == 2; /* R_X86_64_PC32. */
12562 case EM_XTENSA_OLD:
12563 case EM_XTENSA:
12564 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12565 default:
12566 /* Do not abort or issue an error message here. Not all targets use
12567 pc-relative 32-bit relocs in their DWARF debug information and we
12568 have already tested for target coverage in is_32bit_abs_reloc. A
12569 more helpful warning message will be generated by apply_relocations
12570 anyway, so just return. */
12571 return FALSE;
12572 }
12573}
12574
12575/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12576 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12577
12578static bfd_boolean
12579is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12580{
12581 switch (filedata->file_header.e_machine)
12582 {
12583 case EM_AARCH64:
12584 return reloc_type == 257; /* R_AARCH64_ABS64. */
12585 case EM_ALPHA:
12586 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12587 case EM_IA_64:
12588 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12589 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12590 case EM_PARISC:
12591 return reloc_type == 80; /* R_PARISC_DIR64. */
12592 case EM_PPC64:
12593 return reloc_type == 38; /* R_PPC64_ADDR64. */
12594 case EM_RISCV:
12595 return reloc_type == 2; /* R_RISCV_64. */
12596 case EM_SPARC32PLUS:
12597 case EM_SPARCV9:
12598 case EM_SPARC:
12599 return reloc_type == 32 /* R_SPARC_64. */
12600 || reloc_type == 54; /* R_SPARC_UA64. */
12601 case EM_X86_64:
12602 case EM_L1OM:
12603 case EM_K1OM:
12604 return reloc_type == 1; /* R_X86_64_64. */
12605 case EM_S390_OLD:
12606 case EM_S390:
12607 return reloc_type == 22; /* R_S390_64. */
12608 case EM_TILEGX:
12609 return reloc_type == 1; /* R_TILEGX_64. */
12610 case EM_MIPS:
12611 return reloc_type == 18; /* R_MIPS_64. */
12612 default:
12613 return FALSE;
12614 }
12615}
12616
12617/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12618 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12619
12620static bfd_boolean
12621is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12622{
12623 switch (filedata->file_header.e_machine)
12624 {
12625 case EM_AARCH64:
12626 return reloc_type == 260; /* R_AARCH64_PREL64. */
12627 case EM_ALPHA:
12628 return reloc_type == 11; /* R_ALPHA_SREL64. */
12629 case EM_IA_64:
12630 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12631 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12632 case EM_PARISC:
12633 return reloc_type == 72; /* R_PARISC_PCREL64. */
12634 case EM_PPC64:
12635 return reloc_type == 44; /* R_PPC64_REL64. */
12636 case EM_SPARC32PLUS:
12637 case EM_SPARCV9:
12638 case EM_SPARC:
12639 return reloc_type == 46; /* R_SPARC_DISP64. */
12640 case EM_X86_64:
12641 case EM_L1OM:
12642 case EM_K1OM:
12643 return reloc_type == 24; /* R_X86_64_PC64. */
12644 case EM_S390_OLD:
12645 case EM_S390:
12646 return reloc_type == 23; /* R_S390_PC64. */
12647 case EM_TILEGX:
12648 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12649 default:
12650 return FALSE;
12651 }
12652}
12653
12654/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12655 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12656
12657static bfd_boolean
12658is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12659{
12660 switch (filedata->file_header.e_machine)
12661 {
12662 case EM_CYGNUS_MN10200:
12663 case EM_MN10200:
12664 return reloc_type == 4; /* R_MN10200_24. */
12665 case EM_FT32:
12666 return reloc_type == 5; /* R_FT32_20. */
12667 default:
12668 return FALSE;
12669 }
12670}
12671
12672/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12673 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12674
12675static bfd_boolean
12676is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12677{
12678 /* Please keep this table alpha-sorted for ease of visual lookup. */
12679 switch (filedata->file_header.e_machine)
12680 {
12681 case EM_ARC:
12682 case EM_ARC_COMPACT:
12683 case EM_ARC_COMPACT2:
12684 return reloc_type == 2; /* R_ARC_16. */
12685 case EM_ADAPTEVA_EPIPHANY:
12686 return reloc_type == 5;
12687 case EM_AVR_OLD:
12688 case EM_AVR:
12689 return reloc_type == 4; /* R_AVR_16. */
12690 case EM_CYGNUS_D10V:
12691 case EM_D10V:
12692 return reloc_type == 3; /* R_D10V_16. */
12693 case EM_FT32:
12694 return reloc_type == 2; /* R_FT32_16. */
12695 case EM_H8S:
12696 case EM_H8_300:
12697 case EM_H8_300H:
12698 return reloc_type == R_H8_DIR16;
12699 case EM_IP2K_OLD:
12700 case EM_IP2K:
12701 return reloc_type == 1; /* R_IP2K_16. */
12702 case EM_M32C_OLD:
12703 case EM_M32C:
12704 return reloc_type == 1; /* R_M32C_16 */
12705 case EM_CYGNUS_MN10200:
12706 case EM_MN10200:
12707 return reloc_type == 2; /* R_MN10200_16. */
12708 case EM_CYGNUS_MN10300:
12709 case EM_MN10300:
12710 return reloc_type == 2; /* R_MN10300_16. */
12711 case EM_MSP430:
12712 if (uses_msp430x_relocs (filedata))
12713 return reloc_type == 2; /* R_MSP430_ABS16. */
12714 /* Fall through. */
12715 case EM_MSP430_OLD:
12716 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12717 case EM_NDS32:
12718 return reloc_type == 19; /* R_NDS32_RELA. */
12719 case EM_ALTERA_NIOS2:
12720 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12721 case EM_NIOS32:
12722 return reloc_type == 9; /* R_NIOS_16. */
12723 case EM_OR1K:
12724 return reloc_type == 2; /* R_OR1K_16. */
12725 case EM_RISCV:
12726 return reloc_type == 55; /* R_RISCV_SET16. */
12727 case EM_TI_PRU:
12728 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12729 case EM_TI_C6000:
12730 return reloc_type == 2; /* R_C6000_ABS16. */
12731 case EM_VISIUM:
12732 return reloc_type == 2; /* R_VISIUM_16. */
12733 case EM_XC16X:
12734 case EM_C166:
12735 return reloc_type == 2; /* R_XC16C_ABS_16. */
12736 case EM_XGATE:
12737 return reloc_type == 3; /* R_XGATE_16. */
12738 default:
12739 return FALSE;
12740 }
12741}
12742
12743/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12745
12746static bfd_boolean
12747is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12748{
12749 switch (filedata->file_header.e_machine)
12750 {
12751 case EM_RISCV:
12752 return reloc_type == 54; /* R_RISCV_SET8. */
12753 default:
12754 return FALSE;
12755 }
12756}
12757
12758/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12759 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12760
12761static bfd_boolean
12762is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12763{
12764 switch (filedata->file_header.e_machine)
12765 {
12766 case EM_RISCV:
12767 return reloc_type == 53; /* R_RISCV_SET6. */
12768 default:
12769 return FALSE;
12770 }
12771}
12772
12773/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12774 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12775
12776static bfd_boolean
12777is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12778{
12779 /* Please keep this table alpha-sorted for ease of visual lookup. */
12780 switch (filedata->file_header.e_machine)
12781 {
12782 case EM_RISCV:
12783 return reloc_type == 35; /* R_RISCV_ADD32. */
12784 default:
12785 return FALSE;
12786 }
12787}
12788
12789/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12790 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12791
12792static bfd_boolean
12793is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12794{
12795 /* Please keep this table alpha-sorted for ease of visual lookup. */
12796 switch (filedata->file_header.e_machine)
12797 {
12798 case EM_RISCV:
12799 return reloc_type == 39; /* R_RISCV_SUB32. */
12800 default:
12801 return FALSE;
12802 }
12803}
12804
12805/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12806 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12807
12808static bfd_boolean
12809is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12810{
12811 /* Please keep this table alpha-sorted for ease of visual lookup. */
12812 switch (filedata->file_header.e_machine)
12813 {
12814 case EM_RISCV:
12815 return reloc_type == 36; /* R_RISCV_ADD64. */
12816 default:
12817 return FALSE;
12818 }
12819}
12820
12821/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12822 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12823
12824static bfd_boolean
12825is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12826{
12827 /* Please keep this table alpha-sorted for ease of visual lookup. */
12828 switch (filedata->file_header.e_machine)
12829 {
12830 case EM_RISCV:
12831 return reloc_type == 40; /* R_RISCV_SUB64. */
12832 default:
12833 return FALSE;
12834 }
12835}
12836
12837/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12838 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12839
12840static bfd_boolean
12841is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12842{
12843 /* Please keep this table alpha-sorted for ease of visual lookup. */
12844 switch (filedata->file_header.e_machine)
12845 {
12846 case EM_RISCV:
12847 return reloc_type == 34; /* R_RISCV_ADD16. */
12848 default:
12849 return FALSE;
12850 }
12851}
12852
12853/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12854 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12855
12856static bfd_boolean
12857is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12858{
12859 /* Please keep this table alpha-sorted for ease of visual lookup. */
12860 switch (filedata->file_header.e_machine)
12861 {
12862 case EM_RISCV:
12863 return reloc_type == 38; /* R_RISCV_SUB16. */
12864 default:
12865 return FALSE;
12866 }
12867}
12868
12869/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12870 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12871
12872static bfd_boolean
12873is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12874{
12875 /* Please keep this table alpha-sorted for ease of visual lookup. */
12876 switch (filedata->file_header.e_machine)
12877 {
12878 case EM_RISCV:
12879 return reloc_type == 33; /* R_RISCV_ADD8. */
12880 default:
12881 return FALSE;
12882 }
12883}
12884
12885/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12886 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12887
12888static bfd_boolean
12889is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12890{
12891 /* Please keep this table alpha-sorted for ease of visual lookup. */
12892 switch (filedata->file_header.e_machine)
12893 {
12894 case EM_RISCV:
12895 return reloc_type == 37; /* R_RISCV_SUB8. */
12896 default:
12897 return FALSE;
12898 }
12899}
12900
12901/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12902 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12903
12904static bfd_boolean
12905is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12906{
12907 switch (filedata->file_header.e_machine)
12908 {
12909 case EM_RISCV:
12910 return reloc_type == 52; /* R_RISCV_SUB6. */
12911 default:
12912 return FALSE;
12913 }
12914}
12915
12916/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12917 relocation entries (possibly formerly used for SHT_GROUP sections). */
12918
12919static bfd_boolean
12920is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12921{
12922 switch (filedata->file_header.e_machine)
12923 {
12924 case EM_386: /* R_386_NONE. */
12925 case EM_68K: /* R_68K_NONE. */
12926 case EM_ADAPTEVA_EPIPHANY:
12927 case EM_ALPHA: /* R_ALPHA_NONE. */
12928 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12929 case EM_ARC: /* R_ARC_NONE. */
12930 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12931 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12932 case EM_ARM: /* R_ARM_NONE. */
12933 case EM_C166: /* R_XC16X_NONE. */
12934 case EM_CRIS: /* R_CRIS_NONE. */
12935 case EM_FT32: /* R_FT32_NONE. */
12936 case EM_IA_64: /* R_IA64_NONE. */
12937 case EM_K1OM: /* R_X86_64_NONE. */
12938 case EM_L1OM: /* R_X86_64_NONE. */
12939 case EM_M32R: /* R_M32R_NONE. */
12940 case EM_MIPS: /* R_MIPS_NONE. */
12941 case EM_MN10300: /* R_MN10300_NONE. */
12942 case EM_MOXIE: /* R_MOXIE_NONE. */
12943 case EM_NIOS32: /* R_NIOS_NONE. */
12944 case EM_OR1K: /* R_OR1K_NONE. */
12945 case EM_PARISC: /* R_PARISC_NONE. */
12946 case EM_PPC64: /* R_PPC64_NONE. */
12947 case EM_PPC: /* R_PPC_NONE. */
12948 case EM_RISCV: /* R_RISCV_NONE. */
12949 case EM_S390: /* R_390_NONE. */
12950 case EM_S390_OLD:
12951 case EM_SH: /* R_SH_NONE. */
12952 case EM_SPARC32PLUS:
12953 case EM_SPARC: /* R_SPARC_NONE. */
12954 case EM_SPARCV9:
12955 case EM_TILEGX: /* R_TILEGX_NONE. */
12956 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12957 case EM_TI_C6000:/* R_C6000_NONE. */
12958 case EM_X86_64: /* R_X86_64_NONE. */
12959 case EM_XC16X:
12960 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12961 return reloc_type == 0;
12962
12963 case EM_AARCH64:
12964 return reloc_type == 0 || reloc_type == 256;
12965 case EM_AVR_OLD:
12966 case EM_AVR:
12967 return (reloc_type == 0 /* R_AVR_NONE. */
12968 || reloc_type == 30 /* R_AVR_DIFF8. */
12969 || reloc_type == 31 /* R_AVR_DIFF16. */
12970 || reloc_type == 32 /* R_AVR_DIFF32. */);
12971 case EM_METAG:
12972 return reloc_type == 3; /* R_METAG_NONE. */
12973 case EM_NDS32:
12974 return (reloc_type == 0 /* R_XTENSA_NONE. */
12975 || reloc_type == 204 /* R_NDS32_DIFF8. */
12976 || reloc_type == 205 /* R_NDS32_DIFF16. */
12977 || reloc_type == 206 /* R_NDS32_DIFF32. */
12978 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12979 case EM_TI_PRU:
12980 return (reloc_type == 0 /* R_PRU_NONE. */
12981 || reloc_type == 65 /* R_PRU_DIFF8. */
12982 || reloc_type == 66 /* R_PRU_DIFF16. */
12983 || reloc_type == 67 /* R_PRU_DIFF32. */);
12984 case EM_XTENSA_OLD:
12985 case EM_XTENSA:
12986 return (reloc_type == 0 /* R_XTENSA_NONE. */
12987 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12988 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12989 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12990 }
12991 return FALSE;
12992}
12993
12994/* Returns TRUE if there is a relocation against
12995 section NAME at OFFSET bytes. */
12996
12997bfd_boolean
12998reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12999{
13000 Elf_Internal_Rela * relocs;
13001 Elf_Internal_Rela * rp;
13002
13003 if (dsec == NULL || dsec->reloc_info == NULL)
13004 return FALSE;
13005
13006 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13007
13008 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13009 if (rp->r_offset == offset)
13010 return TRUE;
13011
13012 return FALSE;
13013}
13014
13015/* Apply relocations to a section.
13016 Returns TRUE upon success, FALSE otherwise.
13017 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13018 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13019 will be set to the number of relocs loaded.
13020
13021 Note: So far support has been added only for those relocations
13022 which can be found in debug sections. FIXME: Add support for
13023 more relocations ? */
13024
13025static bfd_boolean
13026apply_relocations (Filedata * filedata,
13027 const Elf_Internal_Shdr * section,
13028 unsigned char * start,
13029 bfd_size_type size,
13030 void ** relocs_return,
13031 unsigned long * num_relocs_return)
13032{
13033 Elf_Internal_Shdr * relsec;
13034 unsigned char * end = start + size;
13035 bfd_boolean res = TRUE;
13036
13037 if (relocs_return != NULL)
13038 {
13039 * (Elf_Internal_Rela **) relocs_return = NULL;
13040 * num_relocs_return = 0;
13041 }
13042
13043 if (filedata->file_header.e_type != ET_REL)
13044 /* No relocs to apply. */
13045 return TRUE;
13046
13047 /* Find the reloc section associated with the section. */
13048 for (relsec = filedata->section_headers;
13049 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13050 ++relsec)
13051 {
13052 bfd_boolean is_rela;
13053 unsigned long num_relocs;
13054 Elf_Internal_Rela * relocs;
13055 Elf_Internal_Rela * rp;
13056 Elf_Internal_Shdr * symsec;
13057 Elf_Internal_Sym * symtab;
13058 unsigned long num_syms;
13059 Elf_Internal_Sym * sym;
13060
13061 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13062 || relsec->sh_info >= filedata->file_header.e_shnum
13063 || filedata->section_headers + relsec->sh_info != section
13064 || relsec->sh_size == 0
13065 || relsec->sh_link >= filedata->file_header.e_shnum)
13066 continue;
13067
13068 is_rela = relsec->sh_type == SHT_RELA;
13069
13070 if (is_rela)
13071 {
13072 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13073 relsec->sh_size, & relocs, & num_relocs))
13074 return FALSE;
13075 }
13076 else
13077 {
13078 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13079 relsec->sh_size, & relocs, & num_relocs))
13080 return FALSE;
13081 }
13082
13083 /* SH uses RELA but uses in place value instead of the addend field. */
13084 if (filedata->file_header.e_machine == EM_SH)
13085 is_rela = FALSE;
13086
13087 symsec = filedata->section_headers + relsec->sh_link;
13088 if (symsec->sh_type != SHT_SYMTAB
13089 && symsec->sh_type != SHT_DYNSYM)
13090 return FALSE;
13091 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13092
13093 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13094 {
13095 bfd_vma addend;
13096 unsigned int reloc_type;
13097 unsigned int reloc_size;
13098 bfd_boolean reloc_inplace = FALSE;
13099 bfd_boolean reloc_subtract = FALSE;
13100 unsigned char * rloc;
13101 unsigned long sym_index;
13102
13103 reloc_type = get_reloc_type (filedata, rp->r_info);
13104
13105 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13106 continue;
13107 else if (is_none_reloc (filedata, reloc_type))
13108 continue;
13109 else if (is_32bit_abs_reloc (filedata, reloc_type)
13110 || is_32bit_pcrel_reloc (filedata, reloc_type))
13111 reloc_size = 4;
13112 else if (is_64bit_abs_reloc (filedata, reloc_type)
13113 || is_64bit_pcrel_reloc (filedata, reloc_type))
13114 reloc_size = 8;
13115 else if (is_24bit_abs_reloc (filedata, reloc_type))
13116 reloc_size = 3;
13117 else if (is_16bit_abs_reloc (filedata, reloc_type))
13118 reloc_size = 2;
13119 else if (is_8bit_abs_reloc (filedata, reloc_type)
13120 || is_6bit_abs_reloc (filedata, reloc_type))
13121 reloc_size = 1;
13122 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13123 reloc_type))
13124 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13125 {
13126 reloc_size = 4;
13127 reloc_inplace = TRUE;
13128 }
13129 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13130 reloc_type))
13131 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13132 {
13133 reloc_size = 8;
13134 reloc_inplace = TRUE;
13135 }
13136 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13137 reloc_type))
13138 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13139 {
13140 reloc_size = 2;
13141 reloc_inplace = TRUE;
13142 }
13143 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13144 reloc_type))
13145 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13146 {
13147 reloc_size = 1;
13148 reloc_inplace = TRUE;
13149 }
13150 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13151 reloc_type)))
13152 {
13153 reloc_size = 1;
13154 reloc_inplace = TRUE;
13155 }
13156 else
13157 {
13158 static unsigned int prev_reloc = 0;
13159
13160 if (reloc_type != prev_reloc)
13161 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13162 reloc_type, printable_section_name (filedata, section));
13163 prev_reloc = reloc_type;
13164 res = FALSE;
13165 continue;
13166 }
13167
13168 rloc = start + rp->r_offset;
13169 if ((rloc + reloc_size) > end || (rloc < start))
13170 {
13171 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13172 (unsigned long) rp->r_offset,
13173 printable_section_name (filedata, section));
13174 res = FALSE;
13175 continue;
13176 }
13177
13178 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13179 if (sym_index >= num_syms)
13180 {
13181 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13182 sym_index, printable_section_name (filedata, section));
13183 res = FALSE;
13184 continue;
13185 }
13186 sym = symtab + sym_index;
13187
13188 /* If the reloc has a symbol associated with it,
13189 make sure that it is of an appropriate type.
13190
13191 Relocations against symbols without type can happen.
13192 Gcc -feliminate-dwarf2-dups may generate symbols
13193 without type for debug info.
13194
13195 Icc generates relocations against function symbols
13196 instead of local labels.
13197
13198 Relocations against object symbols can happen, eg when
13199 referencing a global array. For an example of this see
13200 the _clz.o binary in libgcc.a. */
13201 if (sym != symtab
13202 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13203 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13204 {
13205 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13206 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13207 printable_section_name (filedata, relsec),
13208 (long int)(rp - relocs));
13209 res = FALSE;
13210 continue;
13211 }
13212
13213 addend = 0;
13214 if (is_rela)
13215 addend += rp->r_addend;
13216 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13217 partial_inplace. */
13218 if (!is_rela
13219 || (filedata->file_header.e_machine == EM_XTENSA
13220 && reloc_type == 1)
13221 || ((filedata->file_header.e_machine == EM_PJ
13222 || filedata->file_header.e_machine == EM_PJ_OLD)
13223 && reloc_type == 1)
13224 || ((filedata->file_header.e_machine == EM_D30V
13225 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13226 && reloc_type == 12)
13227 || reloc_inplace)
13228 {
13229 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13230 addend += byte_get (rloc, reloc_size) & 0x3f;
13231 else
13232 addend += byte_get (rloc, reloc_size);
13233 }
13234
13235 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13236 || is_64bit_pcrel_reloc (filedata, reloc_type))
13237 {
13238 /* On HPPA, all pc-relative relocations are biased by 8. */
13239 if (filedata->file_header.e_machine == EM_PARISC)
13240 addend -= 8;
13241 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13242 reloc_size);
13243 }
13244 else if (is_6bit_abs_reloc (filedata, reloc_type)
13245 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13246 {
13247 if (reloc_subtract)
13248 addend -= sym->st_value;
13249 else
13250 addend += sym->st_value;
13251 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13252 byte_put (rloc, addend, reloc_size);
13253 }
13254 else if (reloc_subtract)
13255 byte_put (rloc, addend - sym->st_value, reloc_size);
13256 else
13257 byte_put (rloc, addend + sym->st_value, reloc_size);
13258 }
13259
13260 free (symtab);
13261 /* Let the target specific reloc processing code know that
13262 we have finished with these relocs. */
13263 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13264
13265 if (relocs_return)
13266 {
13267 * (Elf_Internal_Rela **) relocs_return = relocs;
13268 * num_relocs_return = num_relocs;
13269 }
13270 else
13271 free (relocs);
13272
13273 break;
13274 }
13275
13276 return res;
13277}
13278
13279#ifdef SUPPORT_DISASSEMBLY
13280static bfd_boolean
13281disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13282{
13283 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13284
13285 /* FIXME: XXX -- to be done --- XXX */
13286
13287 return TRUE;
13288}
13289#endif
13290
13291/* Reads in the contents of SECTION from FILE, returning a pointer
13292 to a malloc'ed buffer or NULL if something went wrong. */
13293
13294static char *
13295get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13296{
13297 bfd_size_type num_bytes = section->sh_size;
13298
13299 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13300 {
13301 printf (_("Section '%s' has no data to dump.\n"),
13302 printable_section_name (filedata, section));
13303 return NULL;
13304 }
13305
13306 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13307 _("section contents"));
13308}
13309
13310/* Uncompresses a section that was compressed using zlib, in place. */
13311
13312static bfd_boolean
13313uncompress_section_contents (unsigned char ** buffer,
13314 dwarf_size_type uncompressed_size,
13315 dwarf_size_type * size)
13316{
13317 dwarf_size_type compressed_size = *size;
13318 unsigned char * compressed_buffer = *buffer;
13319 unsigned char * uncompressed_buffer;
13320 z_stream strm;
13321 int rc;
13322
13323 /* It is possible the section consists of several compressed
13324 buffers concatenated together, so we uncompress in a loop. */
13325 /* PR 18313: The state field in the z_stream structure is supposed
13326 to be invisible to the user (ie us), but some compilers will
13327 still complain about it being used without initialisation. So
13328 we first zero the entire z_stream structure and then set the fields
13329 that we need. */
13330 memset (& strm, 0, sizeof strm);
13331 strm.avail_in = compressed_size;
13332 strm.next_in = (Bytef *) compressed_buffer;
13333 strm.avail_out = uncompressed_size;
13334 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13335
13336 rc = inflateInit (& strm);
13337 while (strm.avail_in > 0)
13338 {
13339 if (rc != Z_OK)
13340 goto fail;
13341 strm.next_out = ((Bytef *) uncompressed_buffer
13342 + (uncompressed_size - strm.avail_out));
13343 rc = inflate (&strm, Z_FINISH);
13344 if (rc != Z_STREAM_END)
13345 goto fail;
13346 rc = inflateReset (& strm);
13347 }
13348 rc = inflateEnd (& strm);
13349 if (rc != Z_OK
13350 || strm.avail_out != 0)
13351 goto fail;
13352
13353 *buffer = uncompressed_buffer;
13354 *size = uncompressed_size;
13355 return TRUE;
13356
13357 fail:
13358 free (uncompressed_buffer);
13359 /* Indicate decompression failure. */
13360 *buffer = NULL;
13361 return FALSE;
13362}
13363
13364static bfd_boolean
13365dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13366{
13367 Elf_Internal_Shdr * relsec;
13368 bfd_size_type num_bytes;
13369 unsigned char * data;
13370 unsigned char * end;
13371 unsigned char * real_start;
13372 unsigned char * start;
13373 bfd_boolean some_strings_shown;
13374
13375 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13376 if (start == NULL)
13377 /* PR 21820: Do not fail if the section was empty. */
13378 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13379
13380 num_bytes = section->sh_size;
13381
13382 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13383
13384 if (decompress_dumps)
13385 {
13386 dwarf_size_type new_size = num_bytes;
13387 dwarf_size_type uncompressed_size = 0;
13388
13389 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13390 {
13391 Elf_Internal_Chdr chdr;
13392 unsigned int compression_header_size
13393 = get_compression_header (& chdr, (unsigned char *) start,
13394 num_bytes);
13395
13396 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13397 {
13398 warn (_("section '%s' has unsupported compress type: %d\n"),
13399 printable_section_name (filedata, section), chdr.ch_type);
13400 return FALSE;
13401 }
13402 else if (chdr.ch_addralign != section->sh_addralign)
13403 {
13404 warn (_("compressed section '%s' is corrupted\n"),
13405 printable_section_name (filedata, section));
13406 return FALSE;
13407 }
13408 uncompressed_size = chdr.ch_size;
13409 start += compression_header_size;
13410 new_size -= compression_header_size;
13411 }
13412 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13413 {
13414 /* Read the zlib header. In this case, it should be "ZLIB"
13415 followed by the uncompressed section size, 8 bytes in
13416 big-endian order. */
13417 uncompressed_size = start[4]; uncompressed_size <<= 8;
13418 uncompressed_size += start[5]; uncompressed_size <<= 8;
13419 uncompressed_size += start[6]; uncompressed_size <<= 8;
13420 uncompressed_size += start[7]; uncompressed_size <<= 8;
13421 uncompressed_size += start[8]; uncompressed_size <<= 8;
13422 uncompressed_size += start[9]; uncompressed_size <<= 8;
13423 uncompressed_size += start[10]; uncompressed_size <<= 8;
13424 uncompressed_size += start[11];
13425 start += 12;
13426 new_size -= 12;
13427 }
13428
13429 if (uncompressed_size)
13430 {
13431 if (uncompress_section_contents (& start,
13432 uncompressed_size, & new_size))
13433 num_bytes = new_size;
13434 else
13435 {
13436 error (_("Unable to decompress section %s\n"),
13437 printable_section_name (filedata, section));
13438 return FALSE;
13439 }
13440 }
13441 else
13442 start = real_start;
13443 }
13444
13445 /* If the section being dumped has relocations against it the user might
13446 be expecting these relocations to have been applied. Check for this
13447 case and issue a warning message in order to avoid confusion.
13448 FIXME: Maybe we ought to have an option that dumps a section with
13449 relocs applied ? */
13450 for (relsec = filedata->section_headers;
13451 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13452 ++relsec)
13453 {
13454 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13455 || relsec->sh_info >= filedata->file_header.e_shnum
13456 || filedata->section_headers + relsec->sh_info != section
13457 || relsec->sh_size == 0
13458 || relsec->sh_link >= filedata->file_header.e_shnum)
13459 continue;
13460
13461 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13462 break;
13463 }
13464
13465 data = start;
13466 end = start + num_bytes;
13467 some_strings_shown = FALSE;
13468
13469 while (data < end)
13470 {
13471 while (!ISPRINT (* data))
13472 if (++ data >= end)
13473 break;
13474
13475 if (data < end)
13476 {
13477 size_t maxlen = end - data;
13478
13479#ifndef __MSVCRT__
13480 /* PR 11128: Use two separate invocations in order to work
13481 around bugs in the Solaris 8 implementation of printf. */
13482 printf (" [%6tx] ", data - start);
13483#else
13484 printf (" [%6Ix] ", (size_t) (data - start));
13485#endif
13486 if (maxlen > 0)
13487 {
13488 print_symbol ((int) maxlen, (const char *) data);
13489 putchar ('\n');
13490 data += strnlen ((const char *) data, maxlen);
13491 }
13492 else
13493 {
13494 printf (_("<corrupt>\n"));
13495 data = end;
13496 }
13497 some_strings_shown = TRUE;
13498 }
13499 }
13500
13501 if (! some_strings_shown)
13502 printf (_(" No strings found in this section."));
13503
13504 free (real_start);
13505
13506 putchar ('\n');
13507 return TRUE;
13508}
13509
13510static bfd_boolean
13511dump_section_as_bytes (Elf_Internal_Shdr * section,
13512 Filedata * filedata,
13513 bfd_boolean relocate)
13514{
13515 Elf_Internal_Shdr * relsec;
13516 bfd_size_type bytes;
13517 bfd_size_type section_size;
13518 bfd_vma addr;
13519 unsigned char * data;
13520 unsigned char * real_start;
13521 unsigned char * start;
13522
13523 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13524 if (start == NULL)
13525 /* PR 21820: Do not fail if the section was empty. */
13526 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13527
13528 section_size = section->sh_size;
13529
13530 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13531
13532 if (decompress_dumps)
13533 {
13534 dwarf_size_type new_size = section_size;
13535 dwarf_size_type uncompressed_size = 0;
13536
13537 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13538 {
13539 Elf_Internal_Chdr chdr;
13540 unsigned int compression_header_size
13541 = get_compression_header (& chdr, start, section_size);
13542
13543 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13544 {
13545 warn (_("section '%s' has unsupported compress type: %d\n"),
13546 printable_section_name (filedata, section), chdr.ch_type);
13547 return FALSE;
13548 }
13549 else if (chdr.ch_addralign != section->sh_addralign)
13550 {
13551 warn (_("compressed section '%s' is corrupted\n"),
13552 printable_section_name (filedata, section));
13553 return FALSE;
13554 }
13555 uncompressed_size = chdr.ch_size;
13556 start += compression_header_size;
13557 new_size -= compression_header_size;
13558 }
13559 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13560 {
13561 /* Read the zlib header. In this case, it should be "ZLIB"
13562 followed by the uncompressed section size, 8 bytes in
13563 big-endian order. */
13564 uncompressed_size = start[4]; uncompressed_size <<= 8;
13565 uncompressed_size += start[5]; uncompressed_size <<= 8;
13566 uncompressed_size += start[6]; uncompressed_size <<= 8;
13567 uncompressed_size += start[7]; uncompressed_size <<= 8;
13568 uncompressed_size += start[8]; uncompressed_size <<= 8;
13569 uncompressed_size += start[9]; uncompressed_size <<= 8;
13570 uncompressed_size += start[10]; uncompressed_size <<= 8;
13571 uncompressed_size += start[11];
13572 start += 12;
13573 new_size -= 12;
13574 }
13575
13576 if (uncompressed_size)
13577 {
13578 if (uncompress_section_contents (& start, uncompressed_size,
13579 & new_size))
13580 {
13581 section_size = new_size;
13582 }
13583 else
13584 {
13585 error (_("Unable to decompress section %s\n"),
13586 printable_section_name (filedata, section));
13587 /* FIXME: Print the section anyway ? */
13588 return FALSE;
13589 }
13590 }
13591 else
13592 start = real_start;
13593 }
13594
13595 if (relocate)
13596 {
13597 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13598 return FALSE;
13599 }
13600 else
13601 {
13602 /* If the section being dumped has relocations against it the user might
13603 be expecting these relocations to have been applied. Check for this
13604 case and issue a warning message in order to avoid confusion.
13605 FIXME: Maybe we ought to have an option that dumps a section with
13606 relocs applied ? */
13607 for (relsec = filedata->section_headers;
13608 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13609 ++relsec)
13610 {
13611 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13612 || relsec->sh_info >= filedata->file_header.e_shnum
13613 || filedata->section_headers + relsec->sh_info != section
13614 || relsec->sh_size == 0
13615 || relsec->sh_link >= filedata->file_header.e_shnum)
13616 continue;
13617
13618 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13619 break;
13620 }
13621 }
13622
13623 addr = section->sh_addr;
13624 bytes = section_size;
13625 data = start;
13626
13627 while (bytes)
13628 {
13629 int j;
13630 int k;
13631 int lbytes;
13632
13633 lbytes = (bytes > 16 ? 16 : bytes);
13634
13635 printf (" 0x%8.8lx ", (unsigned long) addr);
13636
13637 for (j = 0; j < 16; j++)
13638 {
13639 if (j < lbytes)
13640 printf ("%2.2x", data[j]);
13641 else
13642 printf (" ");
13643
13644 if ((j & 3) == 3)
13645 printf (" ");
13646 }
13647
13648 for (j = 0; j < lbytes; j++)
13649 {
13650 k = data[j];
13651 if (k >= ' ' && k < 0x7f)
13652 printf ("%c", k);
13653 else
13654 printf (".");
13655 }
13656
13657 putchar ('\n');
13658
13659 data += lbytes;
13660 addr += lbytes;
13661 bytes -= lbytes;
13662 }
13663
13664 free (real_start);
13665
13666 putchar ('\n');
13667 return TRUE;
13668}
13669
13670static bfd_boolean
13671load_specific_debug_section (enum dwarf_section_display_enum debug,
13672 const Elf_Internal_Shdr * sec,
13673 void * data)
13674{
13675 struct dwarf_section * section = &debug_displays [debug].section;
13676 char buf [64];
13677 Filedata * filedata = (Filedata *) data;
13678
13679 if (section->start != NULL)
13680 {
13681 /* If it is already loaded, do nothing. */
13682 if (streq (section->filename, filedata->file_name))
13683 return TRUE;
13684 free (section->start);
13685 }
13686
13687 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13688 section->address = sec->sh_addr;
13689 section->user_data = NULL;
13690 section->filename = filedata->file_name;
13691 section->start = (unsigned char *) get_data (NULL, filedata,
13692 sec->sh_offset, 1,
13693 sec->sh_size, buf);
13694 if (section->start == NULL)
13695 section->size = 0;
13696 else
13697 {
13698 unsigned char *start = section->start;
13699 dwarf_size_type size = sec->sh_size;
13700 dwarf_size_type uncompressed_size = 0;
13701
13702 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13703 {
13704 Elf_Internal_Chdr chdr;
13705 unsigned int compression_header_size;
13706
13707 if (size < (is_32bit_elf
13708 ? sizeof (Elf32_External_Chdr)
13709 : sizeof (Elf64_External_Chdr)))
13710 {
13711 warn (_("compressed section %s is too small to contain a compression header"),
13712 section->name);
13713 return FALSE;
13714 }
13715
13716 compression_header_size = get_compression_header (&chdr, start, size);
13717
13718 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13719 {
13720 warn (_("section '%s' has unsupported compress type: %d\n"),
13721 section->name, chdr.ch_type);
13722 return FALSE;
13723 }
13724 else if (chdr.ch_addralign != sec->sh_addralign)
13725 {
13726 warn (_("compressed section '%s' is corrupted\n"),
13727 section->name);
13728 return FALSE;
13729 }
13730 uncompressed_size = chdr.ch_size;
13731 start += compression_header_size;
13732 size -= compression_header_size;
13733 }
13734 else if (size > 12 && streq ((char *) start, "ZLIB"))
13735 {
13736 /* Read the zlib header. In this case, it should be "ZLIB"
13737 followed by the uncompressed section size, 8 bytes in
13738 big-endian order. */
13739 uncompressed_size = start[4]; uncompressed_size <<= 8;
13740 uncompressed_size += start[5]; uncompressed_size <<= 8;
13741 uncompressed_size += start[6]; uncompressed_size <<= 8;
13742 uncompressed_size += start[7]; uncompressed_size <<= 8;
13743 uncompressed_size += start[8]; uncompressed_size <<= 8;
13744 uncompressed_size += start[9]; uncompressed_size <<= 8;
13745 uncompressed_size += start[10]; uncompressed_size <<= 8;
13746 uncompressed_size += start[11];
13747 start += 12;
13748 size -= 12;
13749 }
13750
13751 if (uncompressed_size)
13752 {
13753 if (uncompress_section_contents (&start, uncompressed_size,
13754 &size))
13755 {
13756 /* Free the compressed buffer, update the section buffer
13757 and the section size if uncompress is successful. */
13758 free (section->start);
13759 section->start = start;
13760 }
13761 else
13762 {
13763 error (_("Unable to decompress section %s\n"),
13764 printable_section_name (filedata, sec));
13765 return FALSE;
13766 }
13767 }
13768
13769 section->size = size;
13770 }
13771
13772 if (section->start == NULL)
13773 return FALSE;
13774
13775 if (debug_displays [debug].relocate)
13776 {
13777 if (! apply_relocations (filedata, sec, section->start, section->size,
13778 & section->reloc_info, & section->num_relocs))
13779 return FALSE;
13780 }
13781 else
13782 {
13783 section->reloc_info = NULL;
13784 section->num_relocs = 0;
13785 }
13786
13787 return TRUE;
13788}
13789
13790/* If this is not NULL, load_debug_section will only look for sections
13791 within the list of sections given here. */
13792static unsigned int * section_subset = NULL;
13793
13794bfd_boolean
13795load_debug_section (enum dwarf_section_display_enum debug, void * data)
13796{
13797 struct dwarf_section * section = &debug_displays [debug].section;
13798 Elf_Internal_Shdr * sec;
13799 Filedata * filedata = (Filedata *) data;
13800
13801 /* Without section headers we cannot find any sections. */
13802 if (filedata->section_headers == NULL)
13803 return FALSE;
13804
13805 if (filedata->string_table == NULL
13806 && filedata->file_header.e_shstrndx != SHN_UNDEF
13807 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13808 {
13809 Elf_Internal_Shdr * strs;
13810
13811 /* Read in the string table, so that we have section names to scan. */
13812 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13813
13814 if (strs != NULL && strs->sh_size != 0)
13815 {
13816 filedata->string_table
13817 = (char *) get_data (NULL, filedata, strs->sh_offset,
13818 1, strs->sh_size, _("string table"));
13819
13820 filedata->string_table_length
13821 = filedata->string_table != NULL ? strs->sh_size : 0;
13822 }
13823 }
13824
13825 /* Locate the debug section. */
13826 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13827 if (sec != NULL)
13828 section->name = section->uncompressed_name;
13829 else
13830 {
13831 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13832 if (sec != NULL)
13833 section->name = section->compressed_name;
13834 }
13835 if (sec == NULL)
13836 return FALSE;
13837
13838 /* If we're loading from a subset of sections, and we've loaded
13839 a section matching this name before, it's likely that it's a
13840 different one. */
13841 if (section_subset != NULL)
13842 free_debug_section (debug);
13843
13844 return load_specific_debug_section (debug, sec, data);
13845}
13846
13847void
13848free_debug_section (enum dwarf_section_display_enum debug)
13849{
13850 struct dwarf_section * section = &debug_displays [debug].section;
13851
13852 if (section->start == NULL)
13853 return;
13854
13855 free ((char *) section->start);
13856 section->start = NULL;
13857 section->address = 0;
13858 section->size = 0;
13859}
13860
13861static bfd_boolean
13862display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13863{
13864 char * name = SECTION_NAME (section);
13865 const char * print_name = printable_section_name (filedata, section);
13866 bfd_size_type length;
13867 bfd_boolean result = TRUE;
13868 int i;
13869
13870 length = section->sh_size;
13871 if (length == 0)
13872 {
13873 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13874 return TRUE;
13875 }
13876 if (section->sh_type == SHT_NOBITS)
13877 {
13878 /* There is no point in dumping the contents of a debugging section
13879 which has the NOBITS type - the bits in the file will be random.
13880 This can happen when a file containing a .eh_frame section is
13881 stripped with the --only-keep-debug command line option. */
13882 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13883 print_name);
13884 return FALSE;
13885 }
13886
13887 if (const_strneq (name, ".gnu.linkonce.wi."))
13888 name = ".debug_info";
13889
13890 /* See if we know how to display the contents of this section. */
13891 for (i = 0; i < max; i++)
13892 {
13893 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
13894 struct dwarf_section_display * display = debug_displays + i;
13895 struct dwarf_section * sec = & display->section;
13896
13897 if (streq (sec->uncompressed_name, name)
13898 || (id == line && const_strneq (name, ".debug_line."))
13899 || streq (sec->compressed_name, name))
13900 {
13901 bfd_boolean secondary = (section != find_section (filedata, name));
13902
13903 if (secondary)
13904 free_debug_section (id);
13905
13906 if (i == line && const_strneq (name, ".debug_line."))
13907 sec->name = name;
13908 else if (streq (sec->uncompressed_name, name))
13909 sec->name = sec->uncompressed_name;
13910 else
13911 sec->name = sec->compressed_name;
13912
13913 if (load_specific_debug_section (id, section, filedata))
13914 {
13915 /* If this debug section is part of a CU/TU set in a .dwp file,
13916 restrict load_debug_section to the sections in that set. */
13917 section_subset = find_cu_tu_set (filedata, shndx);
13918
13919 result &= display->display (sec, filedata);
13920
13921 section_subset = NULL;
13922
13923 if (secondary || (id != info && id != abbrev))
13924 free_debug_section (id);
13925 }
13926 break;
13927 }
13928 }
13929
13930 if (i == max)
13931 {
13932 printf (_("Unrecognized debug section: %s\n"), print_name);
13933 result = FALSE;
13934 }
13935
13936 return result;
13937}
13938
13939/* Set DUMP_SECTS for all sections where dumps were requested
13940 based on section name. */
13941
13942static void
13943initialise_dumps_byname (Filedata * filedata)
13944{
13945 struct dump_list_entry * cur;
13946
13947 for (cur = dump_sects_byname; cur; cur = cur->next)
13948 {
13949 unsigned int i;
13950 bfd_boolean any = FALSE;
13951
13952 for (i = 0; i < filedata->file_header.e_shnum; i++)
13953 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13954 {
13955 request_dump_bynumber (filedata, i, cur->type);
13956 any = TRUE;
13957 }
13958
13959 if (!any)
13960 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13961 cur->name);
13962 }
13963}
13964
13965static bfd_boolean
13966process_section_contents (Filedata * filedata)
13967{
13968 Elf_Internal_Shdr * section;
13969 unsigned int i;
13970 bfd_boolean res = TRUE;
13971
13972 if (! do_dump)
13973 return TRUE;
13974
13975 initialise_dumps_byname (filedata);
13976
13977 for (i = 0, section = filedata->section_headers;
13978 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13979 i++, section++)
13980 {
13981 dump_type dump = filedata->dump_sects[i];
13982
13983#ifdef SUPPORT_DISASSEMBLY
13984 if (dump & DISASS_DUMP)
13985 {
13986 if (! disassemble_section (section, filedata))
13987 res = FALSE;
13988 }
13989#endif
13990 if (dump & HEX_DUMP)
13991 {
13992 if (! dump_section_as_bytes (section, filedata, FALSE))
13993 res = FALSE;
13994 }
13995
13996 if (dump & RELOC_DUMP)
13997 {
13998 if (! dump_section_as_bytes (section, filedata, TRUE))
13999 res = FALSE;
14000 }
14001
14002 if (dump & STRING_DUMP)
14003 {
14004 if (! dump_section_as_strings (section, filedata))
14005 res = FALSE;
14006 }
14007
14008 if (dump & DEBUG_DUMP)
14009 {
14010 if (! display_debug_section (i, section, filedata))
14011 res = FALSE;
14012 }
14013 }
14014
14015 /* Check to see if the user requested a
14016 dump of a section that does not exist. */
14017 while (i < filedata->num_dump_sects)
14018 {
14019 if (filedata->dump_sects[i])
14020 {
14021 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14022 res = FALSE;
14023 }
14024 i++;
14025 }
14026
14027 return res;
14028}
14029
14030static void
14031process_mips_fpe_exception (int mask)
14032{
14033 if (mask)
14034 {
14035 bfd_boolean first = TRUE;
14036
14037 if (mask & OEX_FPU_INEX)
14038 fputs ("INEX", stdout), first = FALSE;
14039 if (mask & OEX_FPU_UFLO)
14040 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14041 if (mask & OEX_FPU_OFLO)
14042 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14043 if (mask & OEX_FPU_DIV0)
14044 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14045 if (mask & OEX_FPU_INVAL)
14046 printf ("%sINVAL", first ? "" : "|");
14047 }
14048 else
14049 fputs ("0", stdout);
14050}
14051
14052/* Display's the value of TAG at location P. If TAG is
14053 greater than 0 it is assumed to be an unknown tag, and
14054 a message is printed to this effect. Otherwise it is
14055 assumed that a message has already been printed.
14056
14057 If the bottom bit of TAG is set it assumed to have a
14058 string value, otherwise it is assumed to have an integer
14059 value.
14060
14061 Returns an updated P pointing to the first unread byte
14062 beyond the end of TAG's value.
14063
14064 Reads at or beyond END will not be made. */
14065
14066static unsigned char *
14067display_tag_value (signed int tag,
14068 unsigned char * p,
14069 const unsigned char * const end)
14070{
14071 unsigned long val;
14072
14073 if (tag > 0)
14074 printf (" Tag_unknown_%d: ", tag);
14075
14076 if (p >= end)
14077 {
14078 warn (_("<corrupt tag>\n"));
14079 }
14080 else if (tag & 1)
14081 {
14082 /* PR 17531 file: 027-19978-0.004. */
14083 size_t maxlen = (end - p) - 1;
14084
14085 putchar ('"');
14086 if (maxlen > 0)
14087 {
14088 print_symbol ((int) maxlen, (const char *) p);
14089 p += strnlen ((char *) p, maxlen) + 1;
14090 }
14091 else
14092 {
14093 printf (_("<corrupt string tag>"));
14094 p = (unsigned char *) end;
14095 }
14096 printf ("\"\n");
14097 }
14098 else
14099 {
14100 unsigned int len;
14101
14102 val = read_uleb128 (p, &len, end);
14103 p += len;
14104 printf ("%ld (0x%lx)\n", val, val);
14105 }
14106
14107 assert (p <= end);
14108 return p;
14109}
14110
14111/* ARC ABI attributes section. */
14112
14113static unsigned char *
14114display_arc_attribute (unsigned char * p,
14115 const unsigned char * const end)
14116{
14117 unsigned int tag;
14118 unsigned int len;
14119 unsigned int val;
14120
14121 tag = read_uleb128 (p, &len, end);
14122 p += len;
14123
14124 switch (tag)
14125 {
14126 case Tag_ARC_PCS_config:
14127 val = read_uleb128 (p, &len, end);
14128 p += len;
14129 printf (" Tag_ARC_PCS_config: ");
14130 switch (val)
14131 {
14132 case 0:
14133 printf (_("Absent/Non standard\n"));
14134 break;
14135 case 1:
14136 printf (_("Bare metal/mwdt\n"));
14137 break;
14138 case 2:
14139 printf (_("Bare metal/newlib\n"));
14140 break;
14141 case 3:
14142 printf (_("Linux/uclibc\n"));
14143 break;
14144 case 4:
14145 printf (_("Linux/glibc\n"));
14146 break;
14147 default:
14148 printf (_("Unknown\n"));
14149 break;
14150 }
14151 break;
14152
14153 case Tag_ARC_CPU_base:
14154 val = read_uleb128 (p, &len, end);
14155 p += len;
14156 printf (" Tag_ARC_CPU_base: ");
14157 switch (val)
14158 {
14159 default:
14160 case TAG_CPU_NONE:
14161 printf (_("Absent\n"));
14162 break;
14163 case TAG_CPU_ARC6xx:
14164 printf ("ARC6xx\n");
14165 break;
14166 case TAG_CPU_ARC7xx:
14167 printf ("ARC7xx\n");
14168 break;
14169 case TAG_CPU_ARCEM:
14170 printf ("ARCEM\n");
14171 break;
14172 case TAG_CPU_ARCHS:
14173 printf ("ARCHS\n");
14174 break;
14175 }
14176 break;
14177
14178 case Tag_ARC_CPU_variation:
14179 val = read_uleb128 (p, &len, end);
14180 p += len;
14181 printf (" Tag_ARC_CPU_variation: ");
14182 switch (val)
14183 {
14184 default:
14185 if (val > 0 && val < 16)
14186 printf ("Core%d\n", val);
14187 else
14188 printf ("Unknown\n");
14189 break;
14190
14191 case 0:
14192 printf (_("Absent\n"));
14193 break;
14194 }
14195 break;
14196
14197 case Tag_ARC_CPU_name:
14198 printf (" Tag_ARC_CPU_name: ");
14199 p = display_tag_value (-1, p, end);
14200 break;
14201
14202 case Tag_ARC_ABI_rf16:
14203 val = read_uleb128 (p, &len, end);
14204 p += len;
14205 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14206 break;
14207
14208 case Tag_ARC_ABI_osver:
14209 val = read_uleb128 (p, &len, end);
14210 p += len;
14211 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14212 break;
14213
14214 case Tag_ARC_ABI_pic:
14215 case Tag_ARC_ABI_sda:
14216 val = read_uleb128 (p, &len, end);
14217 p += len;
14218 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14219 : " Tag_ARC_ABI_pic: ");
14220 switch (val)
14221 {
14222 case 0:
14223 printf (_("Absent\n"));
14224 break;
14225 case 1:
14226 printf ("MWDT\n");
14227 break;
14228 case 2:
14229 printf ("GNU\n");
14230 break;
14231 default:
14232 printf (_("Unknown\n"));
14233 break;
14234 }
14235 break;
14236
14237 case Tag_ARC_ABI_tls:
14238 val = read_uleb128 (p, &len, end);
14239 p += len;
14240 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14241 break;
14242
14243 case Tag_ARC_ABI_enumsize:
14244 val = read_uleb128 (p, &len, end);
14245 p += len;
14246 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14247 _("smallest"));
14248 break;
14249
14250 case Tag_ARC_ABI_exceptions:
14251 val = read_uleb128 (p, &len, end);
14252 p += len;
14253 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14254 : _("default"));
14255 break;
14256
14257 case Tag_ARC_ABI_double_size:
14258 val = read_uleb128 (p, &len, end);
14259 p += len;
14260 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14261 break;
14262
14263 case Tag_ARC_ISA_config:
14264 printf (" Tag_ARC_ISA_config: ");
14265 p = display_tag_value (-1, p, end);
14266 break;
14267
14268 case Tag_ARC_ISA_apex:
14269 printf (" Tag_ARC_ISA_apex: ");
14270 p = display_tag_value (-1, p, end);
14271 break;
14272
14273 case Tag_ARC_ISA_mpy_option:
14274 val = read_uleb128 (p, &len, end);
14275 p += len;
14276 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14277 break;
14278
14279 case Tag_ARC_ATR_version:
14280 val = read_uleb128 (p, &len, end);
14281 p += len;
14282 printf (" Tag_ARC_ATR_version: %d\n", val);
14283 break;
14284
14285 default:
14286 return display_tag_value (tag & 1, p, end);
14287 }
14288
14289 return p;
14290}
14291
14292/* ARM EABI attributes section. */
14293typedef struct
14294{
14295 unsigned int tag;
14296 const char * name;
14297 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14298 unsigned int type;
14299 const char ** table;
14300} arm_attr_public_tag;
14301
14302static const char * arm_attr_tag_CPU_arch[] =
14303 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14304 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14305 "v8-M.mainline"};
14306static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14307static const char * arm_attr_tag_THUMB_ISA_use[] =
14308 {"No", "Thumb-1", "Thumb-2", "Yes"};
14309static const char * arm_attr_tag_FP_arch[] =
14310 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14311 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14312static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14313static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14314 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14315 "NEON for ARMv8.1"};
14316static const char * arm_attr_tag_PCS_config[] =
14317 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14318 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14319static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14320 {"V6", "SB", "TLS", "Unused"};
14321static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14322 {"Absolute", "PC-relative", "SB-relative", "None"};
14323static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14324 {"Absolute", "PC-relative", "None"};
14325static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14326 {"None", "direct", "GOT-indirect"};
14327static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14328 {"None", "??? 1", "2", "??? 3", "4"};
14329static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14330static const char * arm_attr_tag_ABI_FP_denormal[] =
14331 {"Unused", "Needed", "Sign only"};
14332static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14333static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14334static const char * arm_attr_tag_ABI_FP_number_model[] =
14335 {"Unused", "Finite", "RTABI", "IEEE 754"};
14336static const char * arm_attr_tag_ABI_enum_size[] =
14337 {"Unused", "small", "int", "forced to int"};
14338static const char * arm_attr_tag_ABI_HardFP_use[] =
14339 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14340static const char * arm_attr_tag_ABI_VFP_args[] =
14341 {"AAPCS", "VFP registers", "custom", "compatible"};
14342static const char * arm_attr_tag_ABI_WMMX_args[] =
14343 {"AAPCS", "WMMX registers", "custom"};
14344static const char * arm_attr_tag_ABI_optimization_goals[] =
14345 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14346 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14347static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14348 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14349 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14350static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14351static const char * arm_attr_tag_FP_HP_extension[] =
14352 {"Not Allowed", "Allowed"};
14353static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14354 {"None", "IEEE 754", "Alternative Format"};
14355static const char * arm_attr_tag_DSP_extension[] =
14356 {"Follow architecture", "Allowed"};
14357static const char * arm_attr_tag_MPextension_use[] =
14358 {"Not Allowed", "Allowed"};
14359static const char * arm_attr_tag_DIV_use[] =
14360 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14361 "Allowed in v7-A with integer division extension"};
14362static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14363static const char * arm_attr_tag_Virtualization_use[] =
14364 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14365 "TrustZone and Virtualization Extensions"};
14366static const char * arm_attr_tag_MPextension_use_legacy[] =
14367 {"Not Allowed", "Allowed"};
14368
14369#define LOOKUP(id, name) \
14370 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14371static arm_attr_public_tag arm_attr_public_tags[] =
14372{
14373 {4, "CPU_raw_name", 1, NULL},
14374 {5, "CPU_name", 1, NULL},
14375 LOOKUP(6, CPU_arch),
14376 {7, "CPU_arch_profile", 0, NULL},
14377 LOOKUP(8, ARM_ISA_use),
14378 LOOKUP(9, THUMB_ISA_use),
14379 LOOKUP(10, FP_arch),
14380 LOOKUP(11, WMMX_arch),
14381 LOOKUP(12, Advanced_SIMD_arch),
14382 LOOKUP(13, PCS_config),
14383 LOOKUP(14, ABI_PCS_R9_use),
14384 LOOKUP(15, ABI_PCS_RW_data),
14385 LOOKUP(16, ABI_PCS_RO_data),
14386 LOOKUP(17, ABI_PCS_GOT_use),
14387 LOOKUP(18, ABI_PCS_wchar_t),
14388 LOOKUP(19, ABI_FP_rounding),
14389 LOOKUP(20, ABI_FP_denormal),
14390 LOOKUP(21, ABI_FP_exceptions),
14391 LOOKUP(22, ABI_FP_user_exceptions),
14392 LOOKUP(23, ABI_FP_number_model),
14393 {24, "ABI_align_needed", 0, NULL},
14394 {25, "ABI_align_preserved", 0, NULL},
14395 LOOKUP(26, ABI_enum_size),
14396 LOOKUP(27, ABI_HardFP_use),
14397 LOOKUP(28, ABI_VFP_args),
14398 LOOKUP(29, ABI_WMMX_args),
14399 LOOKUP(30, ABI_optimization_goals),
14400 LOOKUP(31, ABI_FP_optimization_goals),
14401 {32, "compatibility", 0, NULL},
14402 LOOKUP(34, CPU_unaligned_access),
14403 LOOKUP(36, FP_HP_extension),
14404 LOOKUP(38, ABI_FP_16bit_format),
14405 LOOKUP(42, MPextension_use),
14406 LOOKUP(44, DIV_use),
14407 LOOKUP(46, DSP_extension),
14408 {64, "nodefaults", 0, NULL},
14409 {65, "also_compatible_with", 0, NULL},
14410 LOOKUP(66, T2EE_use),
14411 {67, "conformance", 1, NULL},
14412 LOOKUP(68, Virtualization_use),
14413 LOOKUP(70, MPextension_use_legacy)
14414};
14415#undef LOOKUP
14416
14417static unsigned char *
14418display_arm_attribute (unsigned char * p,
14419 const unsigned char * const end)
14420{
14421 unsigned int tag;
14422 unsigned int len;
14423 unsigned int val;
14424 arm_attr_public_tag * attr;
14425 unsigned i;
14426 unsigned int type;
14427
14428 tag = read_uleb128 (p, &len, end);
14429 p += len;
14430 attr = NULL;
14431 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14432 {
14433 if (arm_attr_public_tags[i].tag == tag)
14434 {
14435 attr = &arm_attr_public_tags[i];
14436 break;
14437 }
14438 }
14439
14440 if (attr)
14441 {
14442 printf (" Tag_%s: ", attr->name);
14443 switch (attr->type)
14444 {
14445 case 0:
14446 switch (tag)
14447 {
14448 case 7: /* Tag_CPU_arch_profile. */
14449 val = read_uleb128 (p, &len, end);
14450 p += len;
14451 switch (val)
14452 {
14453 case 0: printf (_("None\n")); break;
14454 case 'A': printf (_("Application\n")); break;
14455 case 'R': printf (_("Realtime\n")); break;
14456 case 'M': printf (_("Microcontroller\n")); break;
14457 case 'S': printf (_("Application or Realtime\n")); break;
14458 default: printf ("??? (%d)\n", val); break;
14459 }
14460 break;
14461
14462 case 24: /* Tag_align_needed. */
14463 val = read_uleb128 (p, &len, end);
14464 p += len;
14465 switch (val)
14466 {
14467 case 0: printf (_("None\n")); break;
14468 case 1: printf (_("8-byte\n")); break;
14469 case 2: printf (_("4-byte\n")); break;
14470 case 3: printf ("??? 3\n"); break;
14471 default:
14472 if (val <= 12)
14473 printf (_("8-byte and up to %d-byte extended\n"),
14474 1 << val);
14475 else
14476 printf ("??? (%d)\n", val);
14477 break;
14478 }
14479 break;
14480
14481 case 25: /* Tag_align_preserved. */
14482 val = read_uleb128 (p, &len, end);
14483 p += len;
14484 switch (val)
14485 {
14486 case 0: printf (_("None\n")); break;
14487 case 1: printf (_("8-byte, except leaf SP\n")); break;
14488 case 2: printf (_("8-byte\n")); break;
14489 case 3: printf ("??? 3\n"); break;
14490 default:
14491 if (val <= 12)
14492 printf (_("8-byte and up to %d-byte extended\n"),
14493 1 << val);
14494 else
14495 printf ("??? (%d)\n", val);
14496 break;
14497 }
14498 break;
14499
14500 case 32: /* Tag_compatibility. */
14501 {
14502 val = read_uleb128 (p, &len, end);
14503 p += len;
14504 printf (_("flag = %d, vendor = "), val);
14505 if (p < end - 1)
14506 {
14507 size_t maxlen = (end - p) - 1;
14508
14509 print_symbol ((int) maxlen, (const char *) p);
14510 p += strnlen ((char *) p, maxlen) + 1;
14511 }
14512 else
14513 {
14514 printf (_("<corrupt>"));
14515 p = (unsigned char *) end;
14516 }
14517 putchar ('\n');
14518 }
14519 break;
14520
14521 case 64: /* Tag_nodefaults. */
14522 /* PR 17531: file: 001-505008-0.01. */
14523 if (p < end)
14524 p++;
14525 printf (_("True\n"));
14526 break;
14527
14528 case 65: /* Tag_also_compatible_with. */
14529 val = read_uleb128 (p, &len, end);
14530 p += len;
14531 if (val == 6 /* Tag_CPU_arch. */)
14532 {
14533 val = read_uleb128 (p, &len, end);
14534 p += len;
14535 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14536 printf ("??? (%d)\n", val);
14537 else
14538 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14539 }
14540 else
14541 printf ("???\n");
14542 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14543 ;
14544 break;
14545
14546 default:
14547 printf (_("<unknown: %d>\n"), tag);
14548 break;
14549 }
14550 return p;
14551
14552 case 1:
14553 return display_tag_value (-1, p, end);
14554 case 2:
14555 return display_tag_value (0, p, end);
14556
14557 default:
14558 assert (attr->type & 0x80);
14559 val = read_uleb128 (p, &len, end);
14560 p += len;
14561 type = attr->type & 0x7f;
14562 if (val >= type)
14563 printf ("??? (%d)\n", val);
14564 else
14565 printf ("%s\n", attr->table[val]);
14566 return p;
14567 }
14568 }
14569
14570 return display_tag_value (tag, p, end);
14571}
14572
14573static unsigned char *
14574display_gnu_attribute (unsigned char * p,
14575 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14576 const unsigned char * const end)
14577{
14578 int tag;
14579 unsigned int len;
14580 unsigned int val;
14581
14582 tag = read_uleb128 (p, &len, end);
14583 p += len;
14584
14585 /* Tag_compatibility is the only generic GNU attribute defined at
14586 present. */
14587 if (tag == 32)
14588 {
14589 val = read_uleb128 (p, &len, end);
14590 p += len;
14591
14592 printf (_("flag = %d, vendor = "), val);
14593 if (p == end)
14594 {
14595 printf (_("<corrupt>\n"));
14596 warn (_("corrupt vendor attribute\n"));
14597 }
14598 else
14599 {
14600 if (p < end - 1)
14601 {
14602 size_t maxlen = (end - p) - 1;
14603
14604 print_symbol ((int) maxlen, (const char *) p);
14605 p += strnlen ((char *) p, maxlen) + 1;
14606 }
14607 else
14608 {
14609 printf (_("<corrupt>"));
14610 p = (unsigned char *) end;
14611 }
14612 putchar ('\n');
14613 }
14614 return p;
14615 }
14616
14617 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14618 return display_proc_gnu_attribute (p, tag, end);
14619
14620 return display_tag_value (tag, p, end);
14621}
14622
14623static unsigned char *
14624display_power_gnu_attribute (unsigned char * p,
14625 unsigned int tag,
14626 const unsigned char * const end)
14627{
14628 unsigned int len;
14629 unsigned int val;
14630
14631 if (tag == Tag_GNU_Power_ABI_FP)
14632 {
14633 val = read_uleb128 (p, &len, end);
14634 p += len;
14635 printf (" Tag_GNU_Power_ABI_FP: ");
14636 if (len == 0)
14637 {
14638 printf (_("<corrupt>\n"));
14639 return p;
14640 }
14641
14642 if (val > 15)
14643 printf ("(%#x), ", val);
14644
14645 switch (val & 3)
14646 {
14647 case 0:
14648 printf (_("unspecified hard/soft float, "));
14649 break;
14650 case 1:
14651 printf (_("hard float, "));
14652 break;
14653 case 2:
14654 printf (_("soft float, "));
14655 break;
14656 case 3:
14657 printf (_("single-precision hard float, "));
14658 break;
14659 }
14660
14661 switch (val & 0xC)
14662 {
14663 case 0:
14664 printf (_("unspecified long double\n"));
14665 break;
14666 case 4:
14667 printf (_("128-bit IBM long double\n"));
14668 break;
14669 case 8:
14670 printf (_("64-bit long double\n"));
14671 break;
14672 case 12:
14673 printf (_("128-bit IEEE long double\n"));
14674 break;
14675 }
14676 return p;
14677 }
14678
14679 if (tag == Tag_GNU_Power_ABI_Vector)
14680 {
14681 val = read_uleb128 (p, &len, end);
14682 p += len;
14683 printf (" Tag_GNU_Power_ABI_Vector: ");
14684 if (len == 0)
14685 {
14686 printf (_("<corrupt>\n"));
14687 return p;
14688 }
14689
14690 if (val > 3)
14691 printf ("(%#x), ", val);
14692
14693 switch (val & 3)
14694 {
14695 case 0:
14696 printf (_("unspecified\n"));
14697 break;
14698 case 1:
14699 printf (_("generic\n"));
14700 break;
14701 case 2:
14702 printf ("AltiVec\n");
14703 break;
14704 case 3:
14705 printf ("SPE\n");
14706 break;
14707 }
14708 return p;
14709 }
14710
14711 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14712 {
14713 val = read_uleb128 (p, &len, end);
14714 p += len;
14715 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14716 if (len == 0)
14717 {
14718 printf (_("<corrupt>\n"));
14719 return p;
14720 }
14721
14722 if (val > 2)
14723 printf ("(%#x), ", val);
14724
14725 switch (val & 3)
14726 {
14727 case 0:
14728 printf (_("unspecified\n"));
14729 break;
14730 case 1:
14731 printf ("r3/r4\n");
14732 break;
14733 case 2:
14734 printf (_("memory\n"));
14735 break;
14736 case 3:
14737 printf ("???\n");
14738 break;
14739 }
14740 return p;
14741 }
14742
14743 return display_tag_value (tag & 1, p, end);
14744}
14745
14746static unsigned char *
14747display_s390_gnu_attribute (unsigned char * p,
14748 unsigned int tag,
14749 const unsigned char * const end)
14750{
14751 unsigned int len;
14752 int val;
14753
14754 if (tag == Tag_GNU_S390_ABI_Vector)
14755 {
14756 val = read_uleb128 (p, &len, end);
14757 p += len;
14758 printf (" Tag_GNU_S390_ABI_Vector: ");
14759
14760 switch (val)
14761 {
14762 case 0:
14763 printf (_("any\n"));
14764 break;
14765 case 1:
14766 printf (_("software\n"));
14767 break;
14768 case 2:
14769 printf (_("hardware\n"));
14770 break;
14771 default:
14772 printf ("??? (%d)\n", val);
14773 break;
14774 }
14775 return p;
14776 }
14777
14778 return display_tag_value (tag & 1, p, end);
14779}
14780
14781static void
14782display_sparc_hwcaps (unsigned int mask)
14783{
14784 if (mask)
14785 {
14786 bfd_boolean first = TRUE;
14787
14788 if (mask & ELF_SPARC_HWCAP_MUL32)
14789 fputs ("mul32", stdout), first = FALSE;
14790 if (mask & ELF_SPARC_HWCAP_DIV32)
14791 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14792 if (mask & ELF_SPARC_HWCAP_FSMULD)
14793 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14794 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14795 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14796 if (mask & ELF_SPARC_HWCAP_POPC)
14797 printf ("%spopc", first ? "" : "|"), first = FALSE;
14798 if (mask & ELF_SPARC_HWCAP_VIS)
14799 printf ("%svis", first ? "" : "|"), first = FALSE;
14800 if (mask & ELF_SPARC_HWCAP_VIS2)
14801 printf ("%svis2", first ? "" : "|"), first = FALSE;
14802 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14803 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14804 if (mask & ELF_SPARC_HWCAP_FMAF)
14805 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14806 if (mask & ELF_SPARC_HWCAP_VIS3)
14807 printf ("%svis3", first ? "" : "|"), first = FALSE;
14808 if (mask & ELF_SPARC_HWCAP_HPC)
14809 printf ("%shpc", first ? "" : "|"), first = FALSE;
14810 if (mask & ELF_SPARC_HWCAP_RANDOM)
14811 printf ("%srandom", first ? "" : "|"), first = FALSE;
14812 if (mask & ELF_SPARC_HWCAP_TRANS)
14813 printf ("%strans", first ? "" : "|"), first = FALSE;
14814 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14815 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14816 if (mask & ELF_SPARC_HWCAP_IMA)
14817 printf ("%sima", first ? "" : "|"), first = FALSE;
14818 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14819 printf ("%scspare", first ? "" : "|"), first = FALSE;
14820 }
14821 else
14822 fputc ('0', stdout);
14823 fputc ('\n', stdout);
14824}
14825
14826static void
14827display_sparc_hwcaps2 (unsigned int mask)
14828{
14829 if (mask)
14830 {
14831 bfd_boolean first = TRUE;
14832
14833 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14834 fputs ("fjathplus", stdout), first = FALSE;
14835 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14836 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14837 if (mask & ELF_SPARC_HWCAP2_ADP)
14838 printf ("%sadp", first ? "" : "|"), first = FALSE;
14839 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14840 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14841 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14842 printf ("%smwait", first ? "" : "|"), first = FALSE;
14843 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14844 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14845 if (mask & ELF_SPARC_HWCAP2_XMONT)
14846 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14847 if (mask & ELF_SPARC_HWCAP2_NSEC)
14848 printf ("%snsec", first ? "" : "|"), first = FALSE;
14849 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14850 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14851 if (mask & ELF_SPARC_HWCAP2_FJDES)
14852 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14853 if (mask & ELF_SPARC_HWCAP2_FJAES)
14854 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14855 }
14856 else
14857 fputc ('0', stdout);
14858 fputc ('\n', stdout);
14859}
14860
14861static unsigned char *
14862display_sparc_gnu_attribute (unsigned char * p,
14863 unsigned int tag,
14864 const unsigned char * const end)
14865{
14866 unsigned int len;
14867 int val;
14868
14869 if (tag == Tag_GNU_Sparc_HWCAPS)
14870 {
14871 val = read_uleb128 (p, &len, end);
14872 p += len;
14873 printf (" Tag_GNU_Sparc_HWCAPS: ");
14874 display_sparc_hwcaps (val);
14875 return p;
14876 }
14877 if (tag == Tag_GNU_Sparc_HWCAPS2)
14878 {
14879 val = read_uleb128 (p, &len, end);
14880 p += len;
14881 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14882 display_sparc_hwcaps2 (val);
14883 return p;
14884 }
14885
14886 return display_tag_value (tag, p, end);
14887}
14888
14889static void
14890print_mips_fp_abi_value (unsigned int val)
14891{
14892 switch (val)
14893 {
14894 case Val_GNU_MIPS_ABI_FP_ANY:
14895 printf (_("Hard or soft float\n"));
14896 break;
14897 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14898 printf (_("Hard float (double precision)\n"));
14899 break;
14900 case Val_GNU_MIPS_ABI_FP_SINGLE:
14901 printf (_("Hard float (single precision)\n"));
14902 break;
14903 case Val_GNU_MIPS_ABI_FP_SOFT:
14904 printf (_("Soft float\n"));
14905 break;
14906 case Val_GNU_MIPS_ABI_FP_OLD_64:
14907 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14908 break;
14909 case Val_GNU_MIPS_ABI_FP_XX:
14910 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14911 break;
14912 case Val_GNU_MIPS_ABI_FP_64:
14913 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14914 break;
14915 case Val_GNU_MIPS_ABI_FP_64A:
14916 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14917 break;
14918 case Val_GNU_MIPS_ABI_FP_NAN2008:
14919 printf (_("NaN 2008 compatibility\n"));
14920 break;
14921 default:
14922 printf ("??? (%d)\n", val);
14923 break;
14924 }
14925}
14926
14927static unsigned char *
14928display_mips_gnu_attribute (unsigned char * p,
14929 unsigned int tag,
14930 const unsigned char * const end)
14931{
14932 if (tag == Tag_GNU_MIPS_ABI_FP)
14933 {
14934 unsigned int len;
14935 unsigned int val;
14936
14937 val = read_uleb128 (p, &len, end);
14938 p += len;
14939 printf (" Tag_GNU_MIPS_ABI_FP: ");
14940
14941 print_mips_fp_abi_value (val);
14942
14943 return p;
14944 }
14945
14946 if (tag == Tag_GNU_MIPS_ABI_MSA)
14947 {
14948 unsigned int len;
14949 unsigned int val;
14950
14951 val = read_uleb128 (p, &len, end);
14952 p += len;
14953 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14954
14955 switch (val)
14956 {
14957 case Val_GNU_MIPS_ABI_MSA_ANY:
14958 printf (_("Any MSA or not\n"));
14959 break;
14960 case Val_GNU_MIPS_ABI_MSA_128:
14961 printf (_("128-bit MSA\n"));
14962 break;
14963 default:
14964 printf ("??? (%d)\n", val);
14965 break;
14966 }
14967 return p;
14968 }
14969
14970 return display_tag_value (tag & 1, p, end);
14971}
14972
14973static unsigned char *
14974display_tic6x_attribute (unsigned char * p,
14975 const unsigned char * const end)
14976{
14977 unsigned int tag;
14978 unsigned int len;
14979 int val;
14980
14981 tag = read_uleb128 (p, &len, end);
14982 p += len;
14983
14984 switch (tag)
14985 {
14986 case Tag_ISA:
14987 val = read_uleb128 (p, &len, end);
14988 p += len;
14989 printf (" Tag_ISA: ");
14990
14991 switch (val)
14992 {
14993 case C6XABI_Tag_ISA_none:
14994 printf (_("None\n"));
14995 break;
14996 case C6XABI_Tag_ISA_C62X:
14997 printf ("C62x\n");
14998 break;
14999 case C6XABI_Tag_ISA_C67X:
15000 printf ("C67x\n");
15001 break;
15002 case C6XABI_Tag_ISA_C67XP:
15003 printf ("C67x+\n");
15004 break;
15005 case C6XABI_Tag_ISA_C64X:
15006 printf ("C64x\n");
15007 break;
15008 case C6XABI_Tag_ISA_C64XP:
15009 printf ("C64x+\n");
15010 break;
15011 case C6XABI_Tag_ISA_C674X:
15012 printf ("C674x\n");
15013 break;
15014 default:
15015 printf ("??? (%d)\n", val);
15016 break;
15017 }
15018 return p;
15019
15020 case Tag_ABI_wchar_t:
15021 val = read_uleb128 (p, &len, end);
15022 p += len;
15023 printf (" Tag_ABI_wchar_t: ");
15024 switch (val)
15025 {
15026 case 0:
15027 printf (_("Not used\n"));
15028 break;
15029 case 1:
15030 printf (_("2 bytes\n"));
15031 break;
15032 case 2:
15033 printf (_("4 bytes\n"));
15034 break;
15035 default:
15036 printf ("??? (%d)\n", val);
15037 break;
15038 }
15039 return p;
15040
15041 case Tag_ABI_stack_align_needed:
15042 val = read_uleb128 (p, &len, end);
15043 p += len;
15044 printf (" Tag_ABI_stack_align_needed: ");
15045 switch (val)
15046 {
15047 case 0:
15048 printf (_("8-byte\n"));
15049 break;
15050 case 1:
15051 printf (_("16-byte\n"));
15052 break;
15053 default:
15054 printf ("??? (%d)\n", val);
15055 break;
15056 }
15057 return p;
15058
15059 case Tag_ABI_stack_align_preserved:
15060 val = read_uleb128 (p, &len, end);
15061 p += len;
15062 printf (" Tag_ABI_stack_align_preserved: ");
15063 switch (val)
15064 {
15065 case 0:
15066 printf (_("8-byte\n"));
15067 break;
15068 case 1:
15069 printf (_("16-byte\n"));
15070 break;
15071 default:
15072 printf ("??? (%d)\n", val);
15073 break;
15074 }
15075 return p;
15076
15077 case Tag_ABI_DSBT:
15078 val = read_uleb128 (p, &len, end);
15079 p += len;
15080 printf (" Tag_ABI_DSBT: ");
15081 switch (val)
15082 {
15083 case 0:
15084 printf (_("DSBT addressing not used\n"));
15085 break;
15086 case 1:
15087 printf (_("DSBT addressing used\n"));
15088 break;
15089 default:
15090 printf ("??? (%d)\n", val);
15091 break;
15092 }
15093 return p;
15094
15095 case Tag_ABI_PID:
15096 val = read_uleb128 (p, &len, end);
15097 p += len;
15098 printf (" Tag_ABI_PID: ");
15099 switch (val)
15100 {
15101 case 0:
15102 printf (_("Data addressing position-dependent\n"));
15103 break;
15104 case 1:
15105 printf (_("Data addressing position-independent, GOT near DP\n"));
15106 break;
15107 case 2:
15108 printf (_("Data addressing position-independent, GOT far from DP\n"));
15109 break;
15110 default:
15111 printf ("??? (%d)\n", val);
15112 break;
15113 }
15114 return p;
15115
15116 case Tag_ABI_PIC:
15117 val = read_uleb128 (p, &len, end);
15118 p += len;
15119 printf (" Tag_ABI_PIC: ");
15120 switch (val)
15121 {
15122 case 0:
15123 printf (_("Code addressing position-dependent\n"));
15124 break;
15125 case 1:
15126 printf (_("Code addressing position-independent\n"));
15127 break;
15128 default:
15129 printf ("??? (%d)\n", val);
15130 break;
15131 }
15132 return p;
15133
15134 case Tag_ABI_array_object_alignment:
15135 val = read_uleb128 (p, &len, end);
15136 p += len;
15137 printf (" Tag_ABI_array_object_alignment: ");
15138 switch (val)
15139 {
15140 case 0:
15141 printf (_("8-byte\n"));
15142 break;
15143 case 1:
15144 printf (_("4-byte\n"));
15145 break;
15146 case 2:
15147 printf (_("16-byte\n"));
15148 break;
15149 default:
15150 printf ("??? (%d)\n", val);
15151 break;
15152 }
15153 return p;
15154
15155 case Tag_ABI_array_object_align_expected:
15156 val = read_uleb128 (p, &len, end);
15157 p += len;
15158 printf (" Tag_ABI_array_object_align_expected: ");
15159 switch (val)
15160 {
15161 case 0:
15162 printf (_("8-byte\n"));
15163 break;
15164 case 1:
15165 printf (_("4-byte\n"));
15166 break;
15167 case 2:
15168 printf (_("16-byte\n"));
15169 break;
15170 default:
15171 printf ("??? (%d)\n", val);
15172 break;
15173 }
15174 return p;
15175
15176 case Tag_ABI_compatibility:
15177 {
15178 val = read_uleb128 (p, &len, end);
15179 p += len;
15180 printf (" Tag_ABI_compatibility: ");
15181 printf (_("flag = %d, vendor = "), val);
15182 if (p < end - 1)
15183 {
15184 size_t maxlen = (end - p) - 1;
15185
15186 print_symbol ((int) maxlen, (const char *) p);
15187 p += strnlen ((char *) p, maxlen) + 1;
15188 }
15189 else
15190 {
15191 printf (_("<corrupt>"));
15192 p = (unsigned char *) end;
15193 }
15194 putchar ('\n');
15195 return p;
15196 }
15197
15198 case Tag_ABI_conformance:
15199 {
15200 printf (" Tag_ABI_conformance: \"");
15201 if (p < end - 1)
15202 {
15203 size_t maxlen = (end - p) - 1;
15204
15205 print_symbol ((int) maxlen, (const char *) p);
15206 p += strnlen ((char *) p, maxlen) + 1;
15207 }
15208 else
15209 {
15210 printf (_("<corrupt>"));
15211 p = (unsigned char *) end;
15212 }
15213 printf ("\"\n");
15214 return p;
15215 }
15216 }
15217
15218 return display_tag_value (tag, p, end);
15219}
15220
15221static void
15222display_raw_attribute (unsigned char * p, unsigned char const * const end)
15223{
15224 unsigned long addr = 0;
15225 size_t bytes = end - p;
15226
15227 assert (end > p);
15228 while (bytes)
15229 {
15230 int j;
15231 int k;
15232 int lbytes = (bytes > 16 ? 16 : bytes);
15233
15234 printf (" 0x%8.8lx ", addr);
15235
15236 for (j = 0; j < 16; j++)
15237 {
15238 if (j < lbytes)
15239 printf ("%2.2x", p[j]);
15240 else
15241 printf (" ");
15242
15243 if ((j & 3) == 3)
15244 printf (" ");
15245 }
15246
15247 for (j = 0; j < lbytes; j++)
15248 {
15249 k = p[j];
15250 if (k >= ' ' && k < 0x7f)
15251 printf ("%c", k);
15252 else
15253 printf (".");
15254 }
15255
15256 putchar ('\n');
15257
15258 p += lbytes;
15259 bytes -= lbytes;
15260 addr += lbytes;
15261 }
15262
15263 putchar ('\n');
15264}
15265
15266static unsigned char *
15267display_msp430x_attribute (unsigned char * p,
15268 const unsigned char * const end)
15269{
15270 unsigned int len;
15271 unsigned int val;
15272 unsigned int tag;
15273
15274 tag = read_uleb128 (p, & len, end);
15275 p += len;
15276
15277 switch (tag)
15278 {
15279 case OFBA_MSPABI_Tag_ISA:
15280 val = read_uleb128 (p, &len, end);
15281 p += len;
15282 printf (" Tag_ISA: ");
15283 switch (val)
15284 {
15285 case 0: printf (_("None\n")); break;
15286 case 1: printf (_("MSP430\n")); break;
15287 case 2: printf (_("MSP430X\n")); break;
15288 default: printf ("??? (%d)\n", val); break;
15289 }
15290 break;
15291
15292 case OFBA_MSPABI_Tag_Code_Model:
15293 val = read_uleb128 (p, &len, end);
15294 p += len;
15295 printf (" Tag_Code_Model: ");
15296 switch (val)
15297 {
15298 case 0: printf (_("None\n")); break;
15299 case 1: printf (_("Small\n")); break;
15300 case 2: printf (_("Large\n")); break;
15301 default: printf ("??? (%d)\n", val); break;
15302 }
15303 break;
15304
15305 case OFBA_MSPABI_Tag_Data_Model:
15306 val = read_uleb128 (p, &len, end);
15307 p += len;
15308 printf (" Tag_Data_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 case 3: printf (_("Restricted Large\n")); break;
15315 default: printf ("??? (%d)\n", val); break;
15316 }
15317 break;
15318
15319 default:
15320 printf (_(" <unknown tag %d>: "), tag);
15321
15322 if (tag & 1)
15323 {
15324 putchar ('"');
15325 if (p < end - 1)
15326 {
15327 size_t maxlen = (end - p) - 1;
15328
15329 print_symbol ((int) maxlen, (const char *) p);
15330 p += strnlen ((char *) p, maxlen) + 1;
15331 }
15332 else
15333 {
15334 printf (_("<corrupt>"));
15335 p = (unsigned char *) end;
15336 }
15337 printf ("\"\n");
15338 }
15339 else
15340 {
15341 val = read_uleb128 (p, &len, end);
15342 p += len;
15343 printf ("%d (0x%x)\n", val, val);
15344 }
15345 break;
15346 }
15347
15348 assert (p <= end);
15349 return p;
15350}
15351
15352static bfd_boolean
15353process_attributes (Filedata * filedata,
15354 const char * public_name,
15355 unsigned int proc_type,
15356 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15357 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15358{
15359 Elf_Internal_Shdr * sect;
15360 unsigned i;
15361 bfd_boolean res = TRUE;
15362
15363 /* Find the section header so that we get the size. */
15364 for (i = 0, sect = filedata->section_headers;
15365 i < filedata->file_header.e_shnum;
15366 i++, sect++)
15367 {
15368 unsigned char * contents;
15369 unsigned char * p;
15370
15371 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15372 continue;
15373
15374 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15375 sect->sh_size, _("attributes"));
15376 if (contents == NULL)
15377 {
15378 res = FALSE;
15379 continue;
15380 }
15381
15382 p = contents;
15383 /* The first character is the version of the attributes.
15384 Currently only version 1, (aka 'A') is recognised here. */
15385 if (*p != 'A')
15386 {
15387 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15388 res = FALSE;
15389 }
15390 else
15391 {
15392 bfd_vma section_len;
15393
15394 section_len = sect->sh_size - 1;
15395 p++;
15396
15397 while (section_len > 0)
15398 {
15399 bfd_vma attr_len;
15400 unsigned int namelen;
15401 bfd_boolean public_section;
15402 bfd_boolean gnu_section;
15403
15404 if (section_len <= 4)
15405 {
15406 error (_("Tag section ends prematurely\n"));
15407 res = FALSE;
15408 break;
15409 }
15410 attr_len = byte_get (p, 4);
15411 p += 4;
15412
15413 if (attr_len > section_len)
15414 {
15415 error (_("Bad attribute length (%u > %u)\n"),
15416 (unsigned) attr_len, (unsigned) section_len);
15417 attr_len = section_len;
15418 res = FALSE;
15419 }
15420 /* PR 17531: file: 001-101425-0.004 */
15421 else if (attr_len < 5)
15422 {
15423 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15424 res = FALSE;
15425 break;
15426 }
15427
15428 section_len -= attr_len;
15429 attr_len -= 4;
15430
15431 namelen = strnlen ((char *) p, attr_len) + 1;
15432 if (namelen == 0 || namelen >= attr_len)
15433 {
15434 error (_("Corrupt attribute section name\n"));
15435 res = FALSE;
15436 break;
15437 }
15438
15439 printf (_("Attribute Section: "));
15440 print_symbol (INT_MAX, (const char *) p);
15441 putchar ('\n');
15442
15443 if (public_name && streq ((char *) p, public_name))
15444 public_section = TRUE;
15445 else
15446 public_section = FALSE;
15447
15448 if (streq ((char *) p, "gnu"))
15449 gnu_section = TRUE;
15450 else
15451 gnu_section = FALSE;
15452
15453 p += namelen;
15454 attr_len -= namelen;
15455
15456 while (attr_len > 0 && p < contents + sect->sh_size)
15457 {
15458 int tag;
15459 int val;
15460 bfd_vma size;
15461 unsigned char * end;
15462
15463 /* PR binutils/17531: Safe handling of corrupt files. */
15464 if (attr_len < 6)
15465 {
15466 error (_("Unused bytes at end of section\n"));
15467 res = FALSE;
15468 section_len = 0;
15469 break;
15470 }
15471
15472 tag = *(p++);
15473 size = byte_get (p, 4);
15474 if (size > attr_len)
15475 {
15476 error (_("Bad subsection length (%u > %u)\n"),
15477 (unsigned) size, (unsigned) attr_len);
15478 res = FALSE;
15479 size = attr_len;
15480 }
15481 /* PR binutils/17531: Safe handling of corrupt files. */
15482 if (size < 6)
15483 {
15484 error (_("Bad subsection length (%u < 6)\n"),
15485 (unsigned) size);
15486 res = FALSE;
15487 section_len = 0;
15488 break;
15489 }
15490
15491 attr_len -= size;
15492 end = p + size - 1;
15493 assert (end <= contents + sect->sh_size);
15494 p += 4;
15495
15496 switch (tag)
15497 {
15498 case 1:
15499 printf (_("File Attributes\n"));
15500 break;
15501 case 2:
15502 printf (_("Section Attributes:"));
15503 goto do_numlist;
15504 case 3:
15505 printf (_("Symbol Attributes:"));
15506 /* Fall through. */
15507 do_numlist:
15508 for (;;)
15509 {
15510 unsigned int j;
15511
15512 val = read_uleb128 (p, &j, end);
15513 p += j;
15514 if (val == 0)
15515 break;
15516 printf (" %d", val);
15517 }
15518 printf ("\n");
15519 break;
15520 default:
15521 printf (_("Unknown tag: %d\n"), tag);
15522 public_section = FALSE;
15523 break;
15524 }
15525
15526 if (public_section && display_pub_attribute != NULL)
15527 {
15528 while (p < end)
15529 p = display_pub_attribute (p, end);
15530 assert (p == end);
15531 }
15532 else if (gnu_section && display_proc_gnu_attribute != NULL)
15533 {
15534 while (p < end)
15535 p = display_gnu_attribute (p,
15536 display_proc_gnu_attribute,
15537 end);
15538 assert (p == end);
15539 }
15540 else if (p < end)
15541 {
15542 printf (_(" Unknown attribute:\n"));
15543 display_raw_attribute (p, end);
15544 p = end;
15545 }
15546 else
15547 attr_len = 0;
15548 }
15549 }
15550 }
15551
15552 free (contents);
15553 }
15554
15555 return res;
15556}
15557
15558/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15559 Print the Address, Access and Initial fields of an entry at VMA ADDR
15560 and return the VMA of the next entry, or -1 if there was a problem.
15561 Does not read from DATA_END or beyond. */
15562
15563static bfd_vma
15564print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15565 unsigned char * data_end)
15566{
15567 printf (" ");
15568 print_vma (addr, LONG_HEX);
15569 printf (" ");
15570 if (addr < pltgot + 0xfff0)
15571 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15572 else
15573 printf ("%10s", "");
15574 printf (" ");
15575 if (data == NULL)
15576 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15577 else
15578 {
15579 bfd_vma entry;
15580 unsigned char * from = data + addr - pltgot;
15581
15582 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15583 {
15584 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15585 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15586 return (bfd_vma) -1;
15587 }
15588 else
15589 {
15590 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15591 print_vma (entry, LONG_HEX);
15592 }
15593 }
15594 return addr + (is_32bit_elf ? 4 : 8);
15595}
15596
15597/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15598 PLTGOT. Print the Address and Initial fields of an entry at VMA
15599 ADDR and return the VMA of the next entry. */
15600
15601static bfd_vma
15602print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15603{
15604 printf (" ");
15605 print_vma (addr, LONG_HEX);
15606 printf (" ");
15607 if (data == NULL)
15608 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15609 else
15610 {
15611 bfd_vma entry;
15612
15613 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15614 print_vma (entry, LONG_HEX);
15615 }
15616 return addr + (is_32bit_elf ? 4 : 8);
15617}
15618
15619static void
15620print_mips_ases (unsigned int mask)
15621{
15622 if (mask & AFL_ASE_DSP)
15623 fputs ("\n\tDSP ASE", stdout);
15624 if (mask & AFL_ASE_DSPR2)
15625 fputs ("\n\tDSP R2 ASE", stdout);
15626 if (mask & AFL_ASE_DSPR3)
15627 fputs ("\n\tDSP R3 ASE", stdout);
15628 if (mask & AFL_ASE_EVA)
15629 fputs ("\n\tEnhanced VA Scheme", stdout);
15630 if (mask & AFL_ASE_MCU)
15631 fputs ("\n\tMCU (MicroController) ASE", stdout);
15632 if (mask & AFL_ASE_MDMX)
15633 fputs ("\n\tMDMX ASE", stdout);
15634 if (mask & AFL_ASE_MIPS3D)
15635 fputs ("\n\tMIPS-3D ASE", stdout);
15636 if (mask & AFL_ASE_MT)
15637 fputs ("\n\tMT ASE", stdout);
15638 if (mask & AFL_ASE_SMARTMIPS)
15639 fputs ("\n\tSmartMIPS ASE", stdout);
15640 if (mask & AFL_ASE_VIRT)
15641 fputs ("\n\tVZ ASE", stdout);
15642 if (mask & AFL_ASE_MSA)
15643 fputs ("\n\tMSA ASE", stdout);
15644 if (mask & AFL_ASE_MIPS16)
15645 fputs ("\n\tMIPS16 ASE", stdout);
15646 if (mask & AFL_ASE_MICROMIPS)
15647 fputs ("\n\tMICROMIPS ASE", stdout);
15648 if (mask & AFL_ASE_XPA)
15649 fputs ("\n\tXPA ASE", stdout);
15650 if (mask & AFL_ASE_MIPS16E2)
15651 fputs ("\n\tMIPS16e2 ASE", stdout);
15652 if (mask & AFL_ASE_CRC)
15653 fputs ("\n\tCRC ASE", stdout);
15654 if (mask & AFL_ASE_GINV)
15655 fputs ("\n\tGINV ASE", stdout);
15656 if (mask & AFL_ASE_LOONGSON_MMI)
15657 fputs ("\n\tLoongson MMI ASE", stdout);
15658 if (mask & AFL_ASE_LOONGSON_CAM)
15659 fputs ("\n\tLoongson CAM ASE", stdout);
15660 if (mask & AFL_ASE_LOONGSON_EXT)
15661 fputs ("\n\tLoongson EXT ASE", stdout);
15662 if (mask & AFL_ASE_LOONGSON_EXT2)
15663 fputs ("\n\tLoongson EXT2 ASE", stdout);
15664 if (mask == 0)
15665 fprintf (stdout, "\n\t%s", _("None"));
15666 else if ((mask & ~AFL_ASE_MASK) != 0)
15667 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15668}
15669
15670static void
15671print_mips_isa_ext (unsigned int isa_ext)
15672{
15673 switch (isa_ext)
15674 {
15675 case 0:
15676 fputs (_("None"), stdout);
15677 break;
15678 case AFL_EXT_XLR:
15679 fputs ("RMI XLR", stdout);
15680 break;
15681 case AFL_EXT_OCTEON3:
15682 fputs ("Cavium Networks Octeon3", stdout);
15683 break;
15684 case AFL_EXT_OCTEON2:
15685 fputs ("Cavium Networks Octeon2", stdout);
15686 break;
15687 case AFL_EXT_OCTEONP:
15688 fputs ("Cavium Networks OcteonP", stdout);
15689 break;
15690 case AFL_EXT_OCTEON:
15691 fputs ("Cavium Networks Octeon", stdout);
15692 break;
15693 case AFL_EXT_5900:
15694 fputs ("Toshiba R5900", stdout);
15695 break;
15696 case AFL_EXT_4650:
15697 fputs ("MIPS R4650", stdout);
15698 break;
15699 case AFL_EXT_4010:
15700 fputs ("LSI R4010", stdout);
15701 break;
15702 case AFL_EXT_4100:
15703 fputs ("NEC VR4100", stdout);
15704 break;
15705 case AFL_EXT_3900:
15706 fputs ("Toshiba R3900", stdout);
15707 break;
15708 case AFL_EXT_10000:
15709 fputs ("MIPS R10000", stdout);
15710 break;
15711 case AFL_EXT_SB1:
15712 fputs ("Broadcom SB-1", stdout);
15713 break;
15714 case AFL_EXT_4111:
15715 fputs ("NEC VR4111/VR4181", stdout);
15716 break;
15717 case AFL_EXT_4120:
15718 fputs ("NEC VR4120", stdout);
15719 break;
15720 case AFL_EXT_5400:
15721 fputs ("NEC VR5400", stdout);
15722 break;
15723 case AFL_EXT_5500:
15724 fputs ("NEC VR5500", stdout);
15725 break;
15726 case AFL_EXT_LOONGSON_2E:
15727 fputs ("ST Microelectronics Loongson 2E", stdout);
15728 break;
15729 case AFL_EXT_LOONGSON_2F:
15730 fputs ("ST Microelectronics Loongson 2F", stdout);
15731 break;
15732 case AFL_EXT_INTERAPTIV_MR2:
15733 fputs ("Imagination interAptiv MR2", stdout);
15734 break;
15735 default:
15736 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15737 }
15738}
15739
15740static signed int
15741get_mips_reg_size (int reg_size)
15742{
15743 return (reg_size == AFL_REG_NONE) ? 0
15744 : (reg_size == AFL_REG_32) ? 32
15745 : (reg_size == AFL_REG_64) ? 64
15746 : (reg_size == AFL_REG_128) ? 128
15747 : -1;
15748}
15749
15750static bfd_boolean
15751process_mips_specific (Filedata * filedata)
15752{
15753 Elf_Internal_Dyn * entry;
15754 Elf_Internal_Shdr *sect = NULL;
15755 size_t liblist_offset = 0;
15756 size_t liblistno = 0;
15757 size_t conflictsno = 0;
15758 size_t options_offset = 0;
15759 size_t conflicts_offset = 0;
15760 size_t pltrelsz = 0;
15761 size_t pltrel = 0;
15762 bfd_vma pltgot = 0;
15763 bfd_vma mips_pltgot = 0;
15764 bfd_vma jmprel = 0;
15765 bfd_vma local_gotno = 0;
15766 bfd_vma gotsym = 0;
15767 bfd_vma symtabno = 0;
15768 bfd_boolean res = TRUE;
15769
15770 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15771 display_mips_gnu_attribute))
15772 res = FALSE;
15773
15774 sect = find_section (filedata, ".MIPS.abiflags");
15775
15776 if (sect != NULL)
15777 {
15778 Elf_External_ABIFlags_v0 *abiflags_ext;
15779 Elf_Internal_ABIFlags_v0 abiflags_in;
15780
15781 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15782 {
15783 error (_("Corrupt MIPS ABI Flags section.\n"));
15784 res = FALSE;
15785 }
15786 else
15787 {
15788 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15789 sect->sh_size, _("MIPS ABI Flags section"));
15790 if (abiflags_ext)
15791 {
15792 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15793 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15794 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15795 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15796 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15797 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15798 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15799 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15800 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15801 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15802 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15803
15804 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15805 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15806 if (abiflags_in.isa_rev > 1)
15807 printf ("r%d", abiflags_in.isa_rev);
15808 printf ("\nGPR size: %d",
15809 get_mips_reg_size (abiflags_in.gpr_size));
15810 printf ("\nCPR1 size: %d",
15811 get_mips_reg_size (abiflags_in.cpr1_size));
15812 printf ("\nCPR2 size: %d",
15813 get_mips_reg_size (abiflags_in.cpr2_size));
15814 fputs ("\nFP ABI: ", stdout);
15815 print_mips_fp_abi_value (abiflags_in.fp_abi);
15816 fputs ("ISA Extension: ", stdout);
15817 print_mips_isa_ext (abiflags_in.isa_ext);
15818 fputs ("\nASEs:", stdout);
15819 print_mips_ases (abiflags_in.ases);
15820 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15821 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15822 fputc ('\n', stdout);
15823 free (abiflags_ext);
15824 }
15825 }
15826 }
15827
15828 /* We have a lot of special sections. Thanks SGI! */
15829 if (dynamic_section == NULL)
15830 {
15831 /* No dynamic information available. See if there is static GOT. */
15832 sect = find_section (filedata, ".got");
15833 if (sect != NULL)
15834 {
15835 unsigned char *data_end;
15836 unsigned char *data;
15837 bfd_vma ent, end;
15838 int addr_size;
15839
15840 pltgot = sect->sh_addr;
15841
15842 ent = pltgot;
15843 addr_size = (is_32bit_elf ? 4 : 8);
15844 end = pltgot + sect->sh_size;
15845
15846 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15847 end - pltgot, 1,
15848 _("Global Offset Table data"));
15849 /* PR 12855: Null data is handled gracefully throughout. */
15850 data_end = data + (end - pltgot);
15851
15852 printf (_("\nStatic GOT:\n"));
15853 printf (_(" Canonical gp value: "));
15854 print_vma (ent + 0x7ff0, LONG_HEX);
15855 printf ("\n\n");
15856
15857 /* In a dynamic binary GOT[0] is reserved for the dynamic
15858 loader to store the lazy resolver pointer, however in
15859 a static binary it may well have been omitted and GOT
15860 reduced to a table of addresses.
15861 PR 21344: Check for the entry being fully available
15862 before fetching it. */
15863 if (data
15864 && data + ent - pltgot + addr_size <= data_end
15865 && byte_get (data + ent - pltgot, addr_size) == 0)
15866 {
15867 printf (_(" Reserved entries:\n"));
15868 printf (_(" %*s %10s %*s\n"),
15869 addr_size * 2, _("Address"), _("Access"),
15870 addr_size * 2, _("Value"));
15871 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15872 printf ("\n");
15873 if (ent == (bfd_vma) -1)
15874 goto sgot_print_fail;
15875
15876 /* Check for the MSB of GOT[1] being set, identifying a
15877 GNU object. This entry will be used by some runtime
15878 loaders, to store the module pointer. Otherwise this
15879 is an ordinary local entry.
15880 PR 21344: Check for the entry being fully available
15881 before fetching it. */
15882 if (data
15883 && data + ent - pltgot + addr_size <= data_end
15884 && (byte_get (data + ent - pltgot, addr_size)
15885 >> (addr_size * 8 - 1)) != 0)
15886 {
15887 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15888 printf ("\n");
15889 if (ent == (bfd_vma) -1)
15890 goto sgot_print_fail;
15891 }
15892 printf ("\n");
15893 }
15894
15895 if (data != NULL && ent < end)
15896 {
15897 printf (_(" Local entries:\n"));
15898 printf (" %*s %10s %*s\n",
15899 addr_size * 2, _("Address"), _("Access"),
15900 addr_size * 2, _("Value"));
15901 while (ent < end)
15902 {
15903 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15904 printf ("\n");
15905 if (ent == (bfd_vma) -1)
15906 goto sgot_print_fail;
15907 }
15908 printf ("\n");
15909 }
15910
15911 sgot_print_fail:
15912 if (data)
15913 free (data);
15914 }
15915 return res;
15916 }
15917
15918 for (entry = dynamic_section;
15919 /* PR 17531 file: 012-50589-0.004. */
15920 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15921 ++entry)
15922 switch (entry->d_tag)
15923 {
15924 case DT_MIPS_LIBLIST:
15925 liblist_offset
15926 = offset_from_vma (filedata, entry->d_un.d_val,
15927 liblistno * sizeof (Elf32_External_Lib));
15928 break;
15929 case DT_MIPS_LIBLISTNO:
15930 liblistno = entry->d_un.d_val;
15931 break;
15932 case DT_MIPS_OPTIONS:
15933 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15934 break;
15935 case DT_MIPS_CONFLICT:
15936 conflicts_offset
15937 = offset_from_vma (filedata, entry->d_un.d_val,
15938 conflictsno * sizeof (Elf32_External_Conflict));
15939 break;
15940 case DT_MIPS_CONFLICTNO:
15941 conflictsno = entry->d_un.d_val;
15942 break;
15943 case DT_PLTGOT:
15944 pltgot = entry->d_un.d_ptr;
15945 break;
15946 case DT_MIPS_LOCAL_GOTNO:
15947 local_gotno = entry->d_un.d_val;
15948 break;
15949 case DT_MIPS_GOTSYM:
15950 gotsym = entry->d_un.d_val;
15951 break;
15952 case DT_MIPS_SYMTABNO:
15953 symtabno = entry->d_un.d_val;
15954 break;
15955 case DT_MIPS_PLTGOT:
15956 mips_pltgot = entry->d_un.d_ptr;
15957 break;
15958 case DT_PLTREL:
15959 pltrel = entry->d_un.d_val;
15960 break;
15961 case DT_PLTRELSZ:
15962 pltrelsz = entry->d_un.d_val;
15963 break;
15964 case DT_JMPREL:
15965 jmprel = entry->d_un.d_ptr;
15966 break;
15967 default:
15968 break;
15969 }
15970
15971 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15972 {
15973 Elf32_External_Lib * elib;
15974 size_t cnt;
15975
15976 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15977 liblistno,
15978 sizeof (Elf32_External_Lib),
15979 _("liblist section data"));
15980 if (elib)
15981 {
15982 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15983 "\nSection '.liblist' contains %lu entries:\n",
15984 (unsigned long) liblistno),
15985 (unsigned long) liblistno);
15986 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15987 stdout);
15988
15989 for (cnt = 0; cnt < liblistno; ++cnt)
15990 {
15991 Elf32_Lib liblist;
15992 time_t atime;
15993 char timebuf[128];
15994 struct tm * tmp;
15995
15996 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15997 atime = BYTE_GET (elib[cnt].l_time_stamp);
15998 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15999 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16000 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16001
16002 tmp = gmtime (&atime);
16003 snprintf (timebuf, sizeof (timebuf),
16004 "%04u-%02u-%02uT%02u:%02u:%02u",
16005 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16006 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16007
16008 printf ("%3lu: ", (unsigned long) cnt);
16009 if (VALID_DYNAMIC_NAME (liblist.l_name))
16010 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16011 else
16012 printf (_("<corrupt: %9ld>"), liblist.l_name);
16013 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16014 liblist.l_version);
16015
16016 if (liblist.l_flags == 0)
16017 puts (_(" NONE"));
16018 else
16019 {
16020 static const struct
16021 {
16022 const char * name;
16023 int bit;
16024 }
16025 l_flags_vals[] =
16026 {
16027 { " EXACT_MATCH", LL_EXACT_MATCH },
16028 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16029 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16030 { " EXPORTS", LL_EXPORTS },
16031 { " DELAY_LOAD", LL_DELAY_LOAD },
16032 { " DELTA", LL_DELTA }
16033 };
16034 int flags = liblist.l_flags;
16035 size_t fcnt;
16036
16037 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16038 if ((flags & l_flags_vals[fcnt].bit) != 0)
16039 {
16040 fputs (l_flags_vals[fcnt].name, stdout);
16041 flags ^= l_flags_vals[fcnt].bit;
16042 }
16043 if (flags != 0)
16044 printf (" %#x", (unsigned int) flags);
16045
16046 puts ("");
16047 }
16048 }
16049
16050 free (elib);
16051 }
16052 else
16053 res = FALSE;
16054 }
16055
16056 if (options_offset != 0)
16057 {
16058 Elf_External_Options * eopt;
16059 Elf_Internal_Options * iopt;
16060 Elf_Internal_Options * option;
16061 size_t offset;
16062 int cnt;
16063 sect = filedata->section_headers;
16064
16065 /* Find the section header so that we get the size. */
16066 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16067 /* PR 17533 file: 012-277276-0.004. */
16068 if (sect == NULL)
16069 {
16070 error (_("No MIPS_OPTIONS header found\n"));
16071 return FALSE;
16072 }
16073
16074 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16075 sect->sh_size, _("options"));
16076 if (eopt)
16077 {
16078 iopt = (Elf_Internal_Options *)
16079 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16080 if (iopt == NULL)
16081 {
16082 error (_("Out of memory allocating space for MIPS options\n"));
16083 return FALSE;
16084 }
16085
16086 offset = cnt = 0;
16087 option = iopt;
16088
16089 while (offset <= sect->sh_size - sizeof (* eopt))
16090 {
16091 Elf_External_Options * eoption;
16092
16093 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16094
16095 option->kind = BYTE_GET (eoption->kind);
16096 option->size = BYTE_GET (eoption->size);
16097 option->section = BYTE_GET (eoption->section);
16098 option->info = BYTE_GET (eoption->info);
16099
16100 /* PR 17531: file: ffa0fa3b. */
16101 if (option->size < sizeof (* eopt)
16102 || offset + option->size > sect->sh_size)
16103 {
16104 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16105 return FALSE;
16106 }
16107 offset += option->size;
16108
16109 ++option;
16110 ++cnt;
16111 }
16112
16113 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16114 "\nSection '%s' contains %d entries:\n",
16115 cnt),
16116 printable_section_name (filedata, sect), cnt);
16117
16118 option = iopt;
16119 offset = 0;
16120
16121 while (cnt-- > 0)
16122 {
16123 size_t len;
16124
16125 switch (option->kind)
16126 {
16127 case ODK_NULL:
16128 /* This shouldn't happen. */
16129 printf (" NULL %d %lx", option->section, option->info);
16130 break;
16131 case ODK_REGINFO:
16132 printf (" REGINFO ");
16133 if (filedata->file_header.e_machine == EM_MIPS)
16134 {
16135 /* 32bit form. */
16136 Elf32_External_RegInfo * ereg;
16137 Elf32_RegInfo reginfo;
16138
16139 ereg = (Elf32_External_RegInfo *) (option + 1);
16140 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16141 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16142 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16143 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16144 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16145 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16146
16147 printf ("GPR %08lx GP 0x%lx\n",
16148 reginfo.ri_gprmask,
16149 (unsigned long) reginfo.ri_gp_value);
16150 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16151 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16152 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16153 }
16154 else
16155 {
16156 /* 64 bit form. */
16157 Elf64_External_RegInfo * ereg;
16158 Elf64_Internal_RegInfo reginfo;
16159
16160 ereg = (Elf64_External_RegInfo *) (option + 1);
16161 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16162 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16163 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16164 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16165 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16166 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16167
16168 printf ("GPR %08lx GP 0x",
16169 reginfo.ri_gprmask);
16170 printf_vma (reginfo.ri_gp_value);
16171 printf ("\n");
16172
16173 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16174 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16175 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16176 }
16177 ++option;
16178 continue;
16179 case ODK_EXCEPTIONS:
16180 fputs (" EXCEPTIONS fpe_min(", stdout);
16181 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16182 fputs (") fpe_max(", stdout);
16183 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16184 fputs (")", stdout);
16185
16186 if (option->info & OEX_PAGE0)
16187 fputs (" PAGE0", stdout);
16188 if (option->info & OEX_SMM)
16189 fputs (" SMM", stdout);
16190 if (option->info & OEX_FPDBUG)
16191 fputs (" FPDBUG", stdout);
16192 if (option->info & OEX_DISMISS)
16193 fputs (" DISMISS", stdout);
16194 break;
16195 case ODK_PAD:
16196 fputs (" PAD ", stdout);
16197 if (option->info & OPAD_PREFIX)
16198 fputs (" PREFIX", stdout);
16199 if (option->info & OPAD_POSTFIX)
16200 fputs (" POSTFIX", stdout);
16201 if (option->info & OPAD_SYMBOL)
16202 fputs (" SYMBOL", stdout);
16203 break;
16204 case ODK_HWPATCH:
16205 fputs (" HWPATCH ", stdout);
16206 if (option->info & OHW_R4KEOP)
16207 fputs (" R4KEOP", stdout);
16208 if (option->info & OHW_R8KPFETCH)
16209 fputs (" R8KPFETCH", stdout);
16210 if (option->info & OHW_R5KEOP)
16211 fputs (" R5KEOP", stdout);
16212 if (option->info & OHW_R5KCVTL)
16213 fputs (" R5KCVTL", stdout);
16214 break;
16215 case ODK_FILL:
16216 fputs (" FILL ", stdout);
16217 /* XXX Print content of info word? */
16218 break;
16219 case ODK_TAGS:
16220 fputs (" TAGS ", stdout);
16221 /* XXX Print content of info word? */
16222 break;
16223 case ODK_HWAND:
16224 fputs (" HWAND ", stdout);
16225 if (option->info & OHWA0_R4KEOP_CHECKED)
16226 fputs (" R4KEOP_CHECKED", stdout);
16227 if (option->info & OHWA0_R4KEOP_CLEAN)
16228 fputs (" R4KEOP_CLEAN", stdout);
16229 break;
16230 case ODK_HWOR:
16231 fputs (" HWOR ", stdout);
16232 if (option->info & OHWA0_R4KEOP_CHECKED)
16233 fputs (" R4KEOP_CHECKED", stdout);
16234 if (option->info & OHWA0_R4KEOP_CLEAN)
16235 fputs (" R4KEOP_CLEAN", stdout);
16236 break;
16237 case ODK_GP_GROUP:
16238 printf (" GP_GROUP %#06lx self-contained %#06lx",
16239 option->info & OGP_GROUP,
16240 (option->info & OGP_SELF) >> 16);
16241 break;
16242 case ODK_IDENT:
16243 printf (" IDENT %#06lx self-contained %#06lx",
16244 option->info & OGP_GROUP,
16245 (option->info & OGP_SELF) >> 16);
16246 break;
16247 default:
16248 /* This shouldn't happen. */
16249 printf (" %3d ??? %d %lx",
16250 option->kind, option->section, option->info);
16251 break;
16252 }
16253
16254 len = sizeof (* eopt);
16255 while (len < option->size)
16256 {
16257 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16258
16259 if (ISPRINT (datum))
16260 printf ("%c", datum);
16261 else
16262 printf ("\\%03o", datum);
16263 len ++;
16264 }
16265 fputs ("\n", stdout);
16266
16267 offset += option->size;
16268 ++option;
16269 }
16270
16271 free (eopt);
16272 }
16273 else
16274 res = FALSE;
16275 }
16276
16277 if (conflicts_offset != 0 && conflictsno != 0)
16278 {
16279 Elf32_Conflict * iconf;
16280 size_t cnt;
16281
16282 if (dynamic_symbols == NULL)
16283 {
16284 error (_("conflict list found without a dynamic symbol table\n"));
16285 return FALSE;
16286 }
16287
16288 /* PR 21345 - print a slightly more helpful error message
16289 if we are sure that the cmalloc will fail. */
16290 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16291 {
16292 error (_("Overlarge number of conflicts detected: %lx\n"),
16293 (long) conflictsno);
16294 return FALSE;
16295 }
16296
16297 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16298 if (iconf == NULL)
16299 {
16300 error (_("Out of memory allocating space for dynamic conflicts\n"));
16301 return FALSE;
16302 }
16303
16304 if (is_32bit_elf)
16305 {
16306 Elf32_External_Conflict * econf32;
16307
16308 econf32 = (Elf32_External_Conflict *)
16309 get_data (NULL, filedata, conflicts_offset, conflictsno,
16310 sizeof (* econf32), _("conflict"));
16311 if (!econf32)
16312 return FALSE;
16313
16314 for (cnt = 0; cnt < conflictsno; ++cnt)
16315 iconf[cnt] = BYTE_GET (econf32[cnt]);
16316
16317 free (econf32);
16318 }
16319 else
16320 {
16321 Elf64_External_Conflict * econf64;
16322
16323 econf64 = (Elf64_External_Conflict *)
16324 get_data (NULL, filedata, conflicts_offset, conflictsno,
16325 sizeof (* econf64), _("conflict"));
16326 if (!econf64)
16327 return FALSE;
16328
16329 for (cnt = 0; cnt < conflictsno; ++cnt)
16330 iconf[cnt] = BYTE_GET (econf64[cnt]);
16331
16332 free (econf64);
16333 }
16334
16335 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16336 "\nSection '.conflict' contains %lu entries:\n",
16337 (unsigned long) conflictsno),
16338 (unsigned long) conflictsno);
16339 puts (_(" Num: Index Value Name"));
16340
16341 for (cnt = 0; cnt < conflictsno; ++cnt)
16342 {
16343 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16344
16345 if (iconf[cnt] >= num_dynamic_syms)
16346 printf (_("<corrupt symbol index>"));
16347 else
16348 {
16349 Elf_Internal_Sym * psym;
16350
16351 psym = & dynamic_symbols[iconf[cnt]];
16352 print_vma (psym->st_value, FULL_HEX);
16353 putchar (' ');
16354 if (VALID_DYNAMIC_NAME (psym->st_name))
16355 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16356 else
16357 printf (_("<corrupt: %14ld>"), psym->st_name);
16358 }
16359 putchar ('\n');
16360 }
16361
16362 free (iconf);
16363 }
16364
16365 if (pltgot != 0 && local_gotno != 0)
16366 {
16367 bfd_vma ent, local_end, global_end;
16368 size_t i, offset;
16369 unsigned char * data;
16370 unsigned char * data_end;
16371 int addr_size;
16372
16373 ent = pltgot;
16374 addr_size = (is_32bit_elf ? 4 : 8);
16375 local_end = pltgot + local_gotno * addr_size;
16376
16377 /* PR binutils/17533 file: 012-111227-0.004 */
16378 if (symtabno < gotsym)
16379 {
16380 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16381 (unsigned long) gotsym, (unsigned long) symtabno);
16382 return FALSE;
16383 }
16384
16385 global_end = local_end + (symtabno - gotsym) * addr_size;
16386 /* PR 17531: file: 54c91a34. */
16387 if (global_end < local_end)
16388 {
16389 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16390 return FALSE;
16391 }
16392
16393 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16394 data = (unsigned char *) get_data (NULL, filedata, offset,
16395 global_end - pltgot, 1,
16396 _("Global Offset Table data"));
16397 /* PR 12855: Null data is handled gracefully throughout. */
16398 data_end = data + (global_end - pltgot);
16399
16400 printf (_("\nPrimary GOT:\n"));
16401 printf (_(" Canonical gp value: "));
16402 print_vma (pltgot + 0x7ff0, LONG_HEX);
16403 printf ("\n\n");
16404
16405 printf (_(" Reserved entries:\n"));
16406 printf (_(" %*s %10s %*s Purpose\n"),
16407 addr_size * 2, _("Address"), _("Access"),
16408 addr_size * 2, _("Initial"));
16409 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16410 printf (_(" Lazy resolver\n"));
16411 if (ent == (bfd_vma) -1)
16412 goto got_print_fail;
16413
16414 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16415 This entry will be used by some runtime loaders, to store the
16416 module pointer. Otherwise this is an ordinary local entry.
16417 PR 21344: Check for the entry being fully available before
16418 fetching it. */
16419 if (data
16420 && data + ent - pltgot + addr_size <= data_end
16421 && (byte_get (data + ent - pltgot, addr_size)
16422 >> (addr_size * 8 - 1)) != 0)
16423 {
16424 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16425 printf (_(" Module pointer (GNU extension)\n"));
16426 if (ent == (bfd_vma) -1)
16427 goto got_print_fail;
16428 }
16429 printf ("\n");
16430
16431 if (data != NULL && ent < local_end)
16432 {
16433 printf (_(" Local entries:\n"));
16434 printf (" %*s %10s %*s\n",
16435 addr_size * 2, _("Address"), _("Access"),
16436 addr_size * 2, _("Initial"));
16437 while (ent < local_end)
16438 {
16439 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16440 printf ("\n");
16441 if (ent == (bfd_vma) -1)
16442 goto got_print_fail;
16443 }
16444 printf ("\n");
16445 }
16446
16447 if (data != NULL && gotsym < symtabno)
16448 {
16449 int sym_width;
16450
16451 printf (_(" Global entries:\n"));
16452 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16453 addr_size * 2, _("Address"),
16454 _("Access"),
16455 addr_size * 2, _("Initial"),
16456 addr_size * 2, _("Sym.Val."),
16457 _("Type"),
16458 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16459 _("Ndx"), _("Name"));
16460
16461 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16462
16463 for (i = gotsym; i < symtabno; i++)
16464 {
16465 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16466 printf (" ");
16467
16468 if (dynamic_symbols == NULL)
16469 printf (_("<no dynamic symbols>"));
16470 else if (i < num_dynamic_syms)
16471 {
16472 Elf_Internal_Sym * psym = dynamic_symbols + i;
16473
16474 print_vma (psym->st_value, LONG_HEX);
16475 printf (" %-7s %3s ",
16476 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16477 get_symbol_index_type (filedata, psym->st_shndx));
16478
16479 if (VALID_DYNAMIC_NAME (psym->st_name))
16480 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16481 else
16482 printf (_("<corrupt: %14ld>"), psym->st_name);
16483 }
16484 else
16485 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16486 (unsigned long) i);
16487
16488 printf ("\n");
16489 if (ent == (bfd_vma) -1)
16490 break;
16491 }
16492 printf ("\n");
16493 }
16494
16495 got_print_fail:
16496 if (data)
16497 free (data);
16498 }
16499
16500 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16501 {
16502 bfd_vma ent, end;
16503 size_t offset, rel_offset;
16504 unsigned long count, i;
16505 unsigned char * data;
16506 int addr_size, sym_width;
16507 Elf_Internal_Rela * rels;
16508
16509 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16510 if (pltrel == DT_RELA)
16511 {
16512 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16513 return FALSE;
16514 }
16515 else
16516 {
16517 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16518 return FALSE;
16519 }
16520
16521 ent = mips_pltgot;
16522 addr_size = (is_32bit_elf ? 4 : 8);
16523 end = mips_pltgot + (2 + count) * addr_size;
16524
16525 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16526 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16527 1, _("Procedure Linkage Table data"));
16528 if (data == NULL)
16529 return FALSE;
16530
16531 printf ("\nPLT GOT:\n\n");
16532 printf (_(" Reserved entries:\n"));
16533 printf (_(" %*s %*s Purpose\n"),
16534 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16535 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16536 printf (_(" PLT lazy resolver\n"));
16537 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16538 printf (_(" Module pointer\n"));
16539 printf ("\n");
16540
16541 printf (_(" Entries:\n"));
16542 printf (" %*s %*s %*s %-7s %3s %s\n",
16543 addr_size * 2, _("Address"),
16544 addr_size * 2, _("Initial"),
16545 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16546 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16547 for (i = 0; i < count; i++)
16548 {
16549 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16550
16551 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16552 printf (" ");
16553
16554 if (idx >= num_dynamic_syms)
16555 printf (_("<corrupt symbol index: %lu>"), idx);
16556 else
16557 {
16558 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16559
16560 print_vma (psym->st_value, LONG_HEX);
16561 printf (" %-7s %3s ",
16562 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16563 get_symbol_index_type (filedata, psym->st_shndx));
16564 if (VALID_DYNAMIC_NAME (psym->st_name))
16565 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16566 else
16567 printf (_("<corrupt: %14ld>"), psym->st_name);
16568 }
16569 printf ("\n");
16570 }
16571 printf ("\n");
16572
16573 if (data)
16574 free (data);
16575 free (rels);
16576 }
16577
16578 return res;
16579}
16580
16581static bfd_boolean
16582process_nds32_specific (Filedata * filedata)
16583{
16584 Elf_Internal_Shdr *sect = NULL;
16585
16586 sect = find_section (filedata, ".nds32_e_flags");
16587 if (sect != NULL)
16588 {
16589 unsigned int *flag;
16590
16591 printf ("\nNDS32 elf flags section:\n");
16592 flag = get_data (NULL, filedata, sect->sh_offset, 1,
16593 sect->sh_size, _("NDS32 elf flags section"));
16594
16595 if (! flag)
16596 return FALSE;
16597
16598 switch ((*flag) & 0x3)
16599 {
16600 case 0:
16601 printf ("(VEC_SIZE):\tNo entry.\n");
16602 break;
16603 case 1:
16604 printf ("(VEC_SIZE):\t4 bytes\n");
16605 break;
16606 case 2:
16607 printf ("(VEC_SIZE):\t16 bytes\n");
16608 break;
16609 case 3:
16610 printf ("(VEC_SIZE):\treserved\n");
16611 break;
16612 }
16613 }
16614
16615 return TRUE;
16616}
16617
16618static bfd_boolean
16619process_gnu_liblist (Filedata * filedata)
16620{
16621 Elf_Internal_Shdr * section;
16622 Elf_Internal_Shdr * string_sec;
16623 Elf32_External_Lib * elib;
16624 char * strtab;
16625 size_t strtab_size;
16626 size_t cnt;
16627 unsigned long num_liblist;
16628 unsigned i;
16629 bfd_boolean res = TRUE;
16630
16631 if (! do_arch)
16632 return TRUE;
16633
16634 for (i = 0, section = filedata->section_headers;
16635 i < filedata->file_header.e_shnum;
16636 i++, section++)
16637 {
16638 switch (section->sh_type)
16639 {
16640 case SHT_GNU_LIBLIST:
16641 if (section->sh_link >= filedata->file_header.e_shnum)
16642 break;
16643
16644 elib = (Elf32_External_Lib *)
16645 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16646 _("liblist section data"));
16647
16648 if (elib == NULL)
16649 {
16650 res = FALSE;
16651 break;
16652 }
16653
16654 string_sec = filedata->section_headers + section->sh_link;
16655 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16656 string_sec->sh_size,
16657 _("liblist string table"));
16658 if (strtab == NULL
16659 || section->sh_entsize != sizeof (Elf32_External_Lib))
16660 {
16661 free (elib);
16662 free (strtab);
16663 res = FALSE;
16664 break;
16665 }
16666 strtab_size = string_sec->sh_size;
16667
16668 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16669 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16670 "\nLibrary list section '%s' contains %lu entries:\n",
16671 num_liblist),
16672 printable_section_name (filedata, section),
16673 num_liblist);
16674
16675 puts (_(" Library Time Stamp Checksum Version Flags"));
16676
16677 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16678 ++cnt)
16679 {
16680 Elf32_Lib liblist;
16681 time_t atime;
16682 char timebuf[128];
16683 struct tm * tmp;
16684
16685 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16686 atime = BYTE_GET (elib[cnt].l_time_stamp);
16687 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16688 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16689 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16690
16691 tmp = gmtime (&atime);
16692 snprintf (timebuf, sizeof (timebuf),
16693 "%04u-%02u-%02uT%02u:%02u:%02u",
16694 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16695 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16696
16697 printf ("%3lu: ", (unsigned long) cnt);
16698 if (do_wide)
16699 printf ("%-20s", liblist.l_name < strtab_size
16700 ? strtab + liblist.l_name : _("<corrupt>"));
16701 else
16702 printf ("%-20.20s", liblist.l_name < strtab_size
16703 ? strtab + liblist.l_name : _("<corrupt>"));
16704 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16705 liblist.l_version, liblist.l_flags);
16706 }
16707
16708 free (elib);
16709 free (strtab);
16710 }
16711 }
16712
16713 return res;
16714}
16715
16716static const char *
16717get_note_type (Filedata * filedata, unsigned e_type)
16718{
16719 static char buff[64];
16720
16721 if (filedata->file_header.e_type == ET_CORE)
16722 switch (e_type)
16723 {
16724 case NT_AUXV:
16725 return _("NT_AUXV (auxiliary vector)");
16726 case NT_PRSTATUS:
16727 return _("NT_PRSTATUS (prstatus structure)");
16728 case NT_FPREGSET:
16729 return _("NT_FPREGSET (floating point registers)");
16730 case NT_PRPSINFO:
16731 return _("NT_PRPSINFO (prpsinfo structure)");
16732 case NT_TASKSTRUCT:
16733 return _("NT_TASKSTRUCT (task structure)");
16734 case NT_PRXFPREG:
16735 return _("NT_PRXFPREG (user_xfpregs structure)");
16736 case NT_PPC_VMX:
16737 return _("NT_PPC_VMX (ppc Altivec registers)");
16738 case NT_PPC_VSX:
16739 return _("NT_PPC_VSX (ppc VSX registers)");
16740 case NT_PPC_TAR:
16741 return _("NT_PPC_TAR (ppc TAR register)");
16742 case NT_PPC_PPR:
16743 return _("NT_PPC_PPR (ppc PPR register)");
16744 case NT_PPC_DSCR:
16745 return _("NT_PPC_DSCR (ppc DSCR register)");
16746 case NT_PPC_EBB:
16747 return _("NT_PPC_EBB (ppc EBB registers)");
16748 case NT_PPC_PMU:
16749 return _("NT_PPC_PMU (ppc PMU registers)");
16750 case NT_PPC_TM_CGPR:
16751 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16752 case NT_PPC_TM_CFPR:
16753 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16754 case NT_PPC_TM_CVMX:
16755 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16756 case NT_PPC_TM_CVSX:
16757 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16758 case NT_PPC_TM_SPR:
16759 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16760 case NT_PPC_TM_CTAR:
16761 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16762 case NT_PPC_TM_CPPR:
16763 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16764 case NT_PPC_TM_CDSCR:
16765 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16766 case NT_386_TLS:
16767 return _("NT_386_TLS (x86 TLS information)");
16768 case NT_386_IOPERM:
16769 return _("NT_386_IOPERM (x86 I/O permissions)");
16770 case NT_X86_XSTATE:
16771 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16772 case NT_S390_HIGH_GPRS:
16773 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16774 case NT_S390_TIMER:
16775 return _("NT_S390_TIMER (s390 timer register)");
16776 case NT_S390_TODCMP:
16777 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16778 case NT_S390_TODPREG:
16779 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16780 case NT_S390_CTRS:
16781 return _("NT_S390_CTRS (s390 control registers)");
16782 case NT_S390_PREFIX:
16783 return _("NT_S390_PREFIX (s390 prefix register)");
16784 case NT_S390_LAST_BREAK:
16785 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16786 case NT_S390_SYSTEM_CALL:
16787 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16788 case NT_S390_TDB:
16789 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16790 case NT_S390_VXRS_LOW:
16791 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16792 case NT_S390_VXRS_HIGH:
16793 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16794 case NT_S390_GS_CB:
16795 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16796 case NT_S390_GS_BC:
16797 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16798 case NT_ARM_VFP:
16799 return _("NT_ARM_VFP (arm VFP registers)");
16800 case NT_ARM_TLS:
16801 return _("NT_ARM_TLS (AArch TLS registers)");
16802 case NT_ARM_HW_BREAK:
16803 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16804 case NT_ARM_HW_WATCH:
16805 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16806 case NT_PSTATUS:
16807 return _("NT_PSTATUS (pstatus structure)");
16808 case NT_FPREGS:
16809 return _("NT_FPREGS (floating point registers)");
16810 case NT_PSINFO:
16811 return _("NT_PSINFO (psinfo structure)");
16812 case NT_LWPSTATUS:
16813 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16814 case NT_LWPSINFO:
16815 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16816 case NT_WIN32PSTATUS:
16817 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16818 case NT_SIGINFO:
16819 return _("NT_SIGINFO (siginfo_t data)");
16820 case NT_FILE:
16821 return _("NT_FILE (mapped files)");
16822 default:
16823 break;
16824 }
16825 else
16826 switch (e_type)
16827 {
16828 case NT_VERSION:
16829 return _("NT_VERSION (version)");
16830 case NT_ARCH:
16831 return _("NT_ARCH (architecture)");
16832 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16833 return _("OPEN");
16834 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16835 return _("func");
16836 default:
16837 break;
16838 }
16839
16840 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16841 return buff;
16842}
16843
16844static bfd_boolean
16845print_core_note (Elf_Internal_Note *pnote)
16846{
16847 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16848 bfd_vma count, page_size;
16849 unsigned char *descdata, *filenames, *descend;
16850
16851 if (pnote->type != NT_FILE)
16852 {
16853 if (do_wide)
16854 printf ("\n");
16855 return TRUE;
16856 }
16857
16858#ifndef BFD64
16859 if (!is_32bit_elf)
16860 {
16861 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16862 /* Still "successful". */
16863 return TRUE;
16864 }
16865#endif
16866
16867 if (pnote->descsz < 2 * addr_size)
16868 {
16869 error (_(" Malformed note - too short for header\n"));
16870 return FALSE;
16871 }
16872
16873 descdata = (unsigned char *) pnote->descdata;
16874 descend = descdata + pnote->descsz;
16875
16876 if (descdata[pnote->descsz - 1] != '\0')
16877 {
16878 error (_(" Malformed note - does not end with \\0\n"));
16879 return FALSE;
16880 }
16881
16882 count = byte_get (descdata, addr_size);
16883 descdata += addr_size;
16884
16885 page_size = byte_get (descdata, addr_size);
16886 descdata += addr_size;
16887
16888 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16889 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16890 {
16891 error (_(" Malformed note - too short for supplied file count\n"));
16892 return FALSE;
16893 }
16894
16895 printf (_(" Page size: "));
16896 print_vma (page_size, DEC);
16897 printf ("\n");
16898
16899 printf (_(" %*s%*s%*s\n"),
16900 (int) (2 + 2 * addr_size), _("Start"),
16901 (int) (4 + 2 * addr_size), _("End"),
16902 (int) (4 + 2 * addr_size), _("Page Offset"));
16903 filenames = descdata + count * 3 * addr_size;
16904 while (count-- > 0)
16905 {
16906 bfd_vma start, end, file_ofs;
16907
16908 if (filenames == descend)
16909 {
16910 error (_(" Malformed note - filenames end too early\n"));
16911 return FALSE;
16912 }
16913
16914 start = byte_get (descdata, addr_size);
16915 descdata += addr_size;
16916 end = byte_get (descdata, addr_size);
16917 descdata += addr_size;
16918 file_ofs = byte_get (descdata, addr_size);
16919 descdata += addr_size;
16920
16921 printf (" ");
16922 print_vma (start, FULL_HEX);
16923 printf (" ");
16924 print_vma (end, FULL_HEX);
16925 printf (" ");
16926 print_vma (file_ofs, FULL_HEX);
16927 printf ("\n %s\n", filenames);
16928
16929 filenames += 1 + strlen ((char *) filenames);
16930 }
16931
16932 return TRUE;
16933}
16934
16935static const char *
16936get_gnu_elf_note_type (unsigned e_type)
16937{
16938 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16939 switch (e_type)
16940 {
16941 case NT_GNU_ABI_TAG:
16942 return _("NT_GNU_ABI_TAG (ABI version tag)");
16943 case NT_GNU_HWCAP:
16944 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16945 case NT_GNU_BUILD_ID:
16946 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16947 case NT_GNU_GOLD_VERSION:
16948 return _("NT_GNU_GOLD_VERSION (gold version)");
16949 case NT_GNU_PROPERTY_TYPE_0:
16950 return _("NT_GNU_PROPERTY_TYPE_0");
16951 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16952 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16953 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16954 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16955 default:
16956 {
16957 static char buff[64];
16958
16959 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16960 return buff;
16961 }
16962 }
16963}
16964
16965static void
16966decode_x86_compat_isa (unsigned int bitmask)
16967{
16968 while (bitmask)
16969 {
16970 unsigned int bit = bitmask & (- bitmask);
16971
16972 bitmask &= ~ bit;
16973 switch (bit)
16974 {
16975 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16976 printf ("i486");
16977 break;
16978 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16979 printf ("586");
16980 break;
16981 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16982 printf ("686");
16983 break;
16984 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16985 printf ("SSE");
16986 break;
16987 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16988 printf ("SSE2");
16989 break;
16990 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16991 printf ("SSE3");
16992 break;
16993 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16994 printf ("SSSE3");
16995 break;
16996 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16997 printf ("SSE4_1");
16998 break;
16999 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17000 printf ("SSE4_2");
17001 break;
17002 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17003 printf ("AVX");
17004 break;
17005 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17006 printf ("AVX2");
17007 break;
17008 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17009 printf ("AVX512F");
17010 break;
17011 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17012 printf ("AVX512CD");
17013 break;
17014 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17015 printf ("AVX512ER");
17016 break;
17017 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17018 printf ("AVX512PF");
17019 break;
17020 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17021 printf ("AVX512VL");
17022 break;
17023 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17024 printf ("AVX512DQ");
17025 break;
17026 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17027 printf ("AVX512BW");
17028 break;
17029 default:
17030 printf (_("<unknown: %x>"), bit);
17031 break;
17032 }
17033 if (bitmask)
17034 printf (", ");
17035 }
17036}
17037
17038static void
17039decode_x86_isa (unsigned int bitmask)
17040{
17041 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17042 {
17043 printf (_("<None>"));
17044 return;
17045 }
17046 else
17047 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17048
17049 while (bitmask)
17050 {
17051 unsigned int bit = bitmask & (- bitmask);
17052
17053 bitmask &= ~ bit;
17054 switch (bit)
17055 {
17056 case GNU_PROPERTY_X86_ISA_1_CMOV:
17057 printf ("CMOV");
17058 break;
17059 case GNU_PROPERTY_X86_ISA_1_SSE:
17060 printf ("SSE");
17061 break;
17062 case GNU_PROPERTY_X86_ISA_1_SSE2:
17063 printf ("SSE2");
17064 break;
17065 case GNU_PROPERTY_X86_ISA_1_SSE3:
17066 printf ("SSE3");
17067 break;
17068 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17069 printf ("SSSE3");
17070 break;
17071 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17072 printf ("SSE4_1");
17073 break;
17074 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17075 printf ("SSE4_2");
17076 break;
17077 case GNU_PROPERTY_X86_ISA_1_AVX:
17078 printf ("AVX");
17079 break;
17080 case GNU_PROPERTY_X86_ISA_1_AVX2:
17081 printf ("AVX2");
17082 break;
17083 case GNU_PROPERTY_X86_ISA_1_FMA:
17084 printf ("FMA");
17085 break;
17086 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17087 printf ("AVX512F");
17088 break;
17089 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17090 printf ("AVX512CD");
17091 break;
17092 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17093 printf ("AVX512ER");
17094 break;
17095 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17096 printf ("AVX512PF");
17097 break;
17098 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17099 printf ("AVX512VL");
17100 break;
17101 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17102 printf ("AVX512DQ");
17103 break;
17104 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17105 printf ("AVX512BW");
17106 break;
17107 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17108 printf ("AVX512_4FMAPS");
17109 break;
17110 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17111 printf ("AVX512_4VNNIW");
17112 break;
17113 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17114 printf ("AVX512_BITALG");
17115 break;
17116 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17117 printf ("AVX512_IFMA");
17118 break;
17119 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17120 printf ("AVX512_VBMI");
17121 break;
17122 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17123 printf ("AVX512_VBMI2");
17124 break;
17125 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17126 printf ("AVX512_VNNI");
17127 break;
17128 default:
17129 printf (_("<unknown: %x>"), bit);
17130 break;
17131 }
17132 if (bitmask)
17133 printf (", ");
17134 }
17135}
17136
17137static void
17138decode_x86_feature_1 (unsigned int bitmask)
17139{
17140 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17141 {
17142 printf (_("<None>"));
17143 return;
17144 }
17145 else
17146 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17147
17148 while (bitmask)
17149 {
17150 unsigned int bit = bitmask & (- bitmask);
17151
17152 bitmask &= ~ bit;
17153 switch (bit)
17154 {
17155 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17156 printf ("IBT");
17157 break;
17158 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17159 printf ("SHSTK");
17160 break;
17161 default:
17162 printf (_("<unknown: %x>"), bit);
17163 break;
17164 }
17165 if (bitmask)
17166 printf (", ");
17167 }
17168}
17169
17170static void
17171decode_x86_feature_2 (unsigned int bitmask)
17172{
17173 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17174 {
17175 printf (_("<None>"));
17176 return;
17177 }
17178 else
17179 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17180
17181 while (bitmask)
17182 {
17183 unsigned int bit = bitmask & (- bitmask);
17184
17185 bitmask &= ~ bit;
17186 switch (bit)
17187 {
17188 case GNU_PROPERTY_X86_FEATURE_2_X86:
17189 printf ("x86");
17190 break;
17191 case GNU_PROPERTY_X86_FEATURE_2_X87:
17192 printf ("x87");
17193 break;
17194 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17195 printf ("MMX");
17196 break;
17197 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17198 printf ("XMM");
17199 break;
17200 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17201 printf ("YMM");
17202 break;
17203 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17204 printf ("ZMM");
17205 break;
17206 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17207 printf ("FXSR");
17208 break;
17209 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17210 printf ("XSAVE");
17211 break;
17212 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17213 printf ("XSAVEOPT");
17214 break;
17215 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17216 printf ("XSAVEC");
17217 break;
17218 default:
17219 printf (_("<unknown: %x>"), bit);
17220 break;
17221 }
17222 if (bitmask)
17223 printf (", ");
17224 }
17225}
17226
17227static void
17228print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17229{
17230 unsigned char * ptr = (unsigned char *) pnote->descdata;
17231 unsigned char * ptr_end = ptr + pnote->descsz;
17232 unsigned int size = is_32bit_elf ? 4 : 8;
17233
17234 printf (_(" Properties: "));
17235
17236 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17237 {
17238 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17239 return;
17240 }
17241
17242 while (ptr < ptr_end)
17243 {
17244 unsigned int j;
17245 unsigned int type;
17246 unsigned int datasz;
17247
17248 if ((size_t) (ptr_end - ptr) < 8)
17249 {
17250 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17251 break;
17252 }
17253
17254 type = byte_get (ptr, 4);
17255 datasz = byte_get (ptr + 4, 4);
17256
17257 ptr += 8;
17258
17259 if (datasz > (size_t) (ptr_end - ptr))
17260 {
17261 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17262 type, datasz);
17263 break;
17264 }
17265
17266 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17267 {
17268 if (filedata->file_header.e_machine == EM_X86_64
17269 || filedata->file_header.e_machine == EM_IAMCU
17270 || filedata->file_header.e_machine == EM_386)
17271 {
17272 unsigned int bitmask;
17273
17274 if (datasz == 4)
17275 {
17276 bitmask = byte_get (ptr, 4);
17277 if ((filedata->file_header.e_type == ET_EXEC
17278 || filedata->file_header.e_type == ET_DYN)
17279 && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17280 printf ("Invalid ");
17281 }
17282 else
17283 bitmask = 0;
17284
17285 switch (type)
17286 {
17287 case GNU_PROPERTY_X86_ISA_1_USED:
17288 if (datasz != 4)
17289 printf (_("x86 ISA used: <corrupt length: %#x> "),
17290 datasz);
17291 else
17292 {
17293 printf ("x86 ISA used: ");
17294 decode_x86_isa (bitmask);
17295 }
17296 goto next;
17297
17298 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17299 if (datasz != 4)
17300 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17301 datasz);
17302 else
17303 {
17304 printf ("x86 ISA needed: ");
17305 decode_x86_isa (bitmask);
17306 }
17307 goto next;
17308
17309 case GNU_PROPERTY_X86_FEATURE_1_AND:
17310 if (datasz != 4)
17311 printf (_("x86 feature: <corrupt length: %#x> "),
17312 datasz);
17313 else
17314 {
17315 printf ("x86 feature: ");
17316 decode_x86_feature_1 (bitmask);
17317 }
17318 goto next;
17319
17320 case GNU_PROPERTY_X86_FEATURE_2_USED:
17321 if (datasz != 4)
17322 printf (_("x86 feature used: <corrupt length: %#x> "),
17323 datasz);
17324 else
17325 {
17326 printf ("x86 feature used: ");
17327 decode_x86_feature_2 (bitmask);
17328 }
17329 goto next;
17330
17331 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17332 if (datasz != 4)
17333 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17334 else
17335 {
17336 printf ("x86 feature needed: ");
17337 decode_x86_feature_2 (bitmask);
17338 }
17339 goto next;
17340
17341 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17342 if (datasz != 4)
17343 printf (_("x86 ISA used: <corrupt length: %#x> "),
17344 datasz);
17345 else
17346 {
17347 printf ("x86 ISA used: ");
17348 decode_x86_compat_isa (bitmask);
17349 }
17350 goto next;
17351
17352 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17353 if (datasz != 4)
17354 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17355 datasz);
17356 else
17357 {
17358 printf ("x86 ISA needed: ");
17359 decode_x86_compat_isa (bitmask);
17360 }
17361 goto next;
17362
17363 default:
17364 break;
17365 }
17366 }
17367 }
17368 else
17369 {
17370 switch (type)
17371 {
17372 case GNU_PROPERTY_STACK_SIZE:
17373 printf (_("stack size: "));
17374 if (datasz != size)
17375 printf (_("<corrupt length: %#x> "), datasz);
17376 else
17377 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17378 goto next;
17379
17380 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17381 printf ("no copy on protected ");
17382 if (datasz)
17383 printf (_("<corrupt length: %#x> "), datasz);
17384 goto next;
17385
17386 default:
17387 break;
17388 }
17389 }
17390
17391 if (type < GNU_PROPERTY_LOPROC)
17392 printf (_("<unknown type %#x data: "), type);
17393 else if (type < GNU_PROPERTY_LOUSER)
17394 printf (_("<procesor-specific type %#x data: "), type);
17395 else
17396 printf (_("<application-specific type %#x data: "), type);
17397 for (j = 0; j < datasz; ++j)
17398 printf ("%02x ", ptr[j] & 0xff);
17399 printf (">");
17400
17401next:
17402 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17403 if (ptr == ptr_end)
17404 break;
17405
17406 if (do_wide)
17407 printf (", ");
17408 else
17409 printf ("\n\t");
17410 }
17411
17412 printf ("\n");
17413}
17414
17415static bfd_boolean
17416print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17417{
17418 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17419 switch (pnote->type)
17420 {
17421 case NT_GNU_BUILD_ID:
17422 {
17423 unsigned long i;
17424
17425 printf (_(" Build ID: "));
17426 for (i = 0; i < pnote->descsz; ++i)
17427 printf ("%02x", pnote->descdata[i] & 0xff);
17428 printf ("\n");
17429 }
17430 break;
17431
17432 case NT_GNU_ABI_TAG:
17433 {
17434 unsigned long os, major, minor, subminor;
17435 const char *osname;
17436
17437 /* PR 17531: file: 030-599401-0.004. */
17438 if (pnote->descsz < 16)
17439 {
17440 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17441 break;
17442 }
17443
17444 os = byte_get ((unsigned char *) pnote->descdata, 4);
17445 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17446 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17447 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17448
17449 switch (os)
17450 {
17451 case GNU_ABI_TAG_LINUX:
17452 osname = "Linux";
17453 break;
17454 case GNU_ABI_TAG_HURD:
17455 osname = "Hurd";
17456 break;
17457 case GNU_ABI_TAG_SOLARIS:
17458 osname = "Solaris";
17459 break;
17460 case GNU_ABI_TAG_FREEBSD:
17461 osname = "FreeBSD";
17462 break;
17463 case GNU_ABI_TAG_NETBSD:
17464 osname = "NetBSD";
17465 break;
17466 case GNU_ABI_TAG_SYLLABLE:
17467 osname = "Syllable";
17468 break;
17469 case GNU_ABI_TAG_NACL:
17470 osname = "NaCl";
17471 break;
17472 default:
17473 osname = "Unknown";
17474 break;
17475 }
17476
17477 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17478 major, minor, subminor);
17479 }
17480 break;
17481
17482 case NT_GNU_GOLD_VERSION:
17483 {
17484 unsigned long i;
17485
17486 printf (_(" Version: "));
17487 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17488 printf ("%c", pnote->descdata[i]);
17489 printf ("\n");
17490 }
17491 break;
17492
17493 case NT_GNU_HWCAP:
17494 {
17495 unsigned long num_entries, mask;
17496
17497 /* Hardware capabilities information. Word 0 is the number of entries.
17498 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17499 is a series of entries, where each entry is a single byte followed
17500 by a nul terminated string. The byte gives the bit number to test
17501 if enabled in the bitmask. */
17502 printf (_(" Hardware Capabilities: "));
17503 if (pnote->descsz < 8)
17504 {
17505 error (_("<corrupt GNU_HWCAP>\n"));
17506 return FALSE;
17507 }
17508 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17509 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17510 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17511 /* FIXME: Add code to display the entries... */
17512 }
17513 break;
17514
17515 case NT_GNU_PROPERTY_TYPE_0:
17516 print_gnu_property_note (filedata, pnote);
17517 break;
17518
17519 default:
17520 /* Handle unrecognised types. An error message should have already been
17521 created by get_gnu_elf_note_type(), so all that we need to do is to
17522 display the data. */
17523 {
17524 unsigned long i;
17525
17526 printf (_(" Description data: "));
17527 for (i = 0; i < pnote->descsz; ++i)
17528 printf ("%02x ", pnote->descdata[i] & 0xff);
17529 printf ("\n");
17530 }
17531 break;
17532 }
17533
17534 return TRUE;
17535}
17536
17537static const char *
17538get_v850_elf_note_type (enum v850_notes n_type)
17539{
17540 static char buff[64];
17541
17542 switch (n_type)
17543 {
17544 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17545 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17546 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17547 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17548 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17549 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17550 default:
17551 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17552 return buff;
17553 }
17554}
17555
17556static bfd_boolean
17557print_v850_note (Elf_Internal_Note * pnote)
17558{
17559 unsigned int val;
17560
17561 if (pnote->descsz != 4)
17562 return FALSE;
17563
17564 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17565
17566 if (val == 0)
17567 {
17568 printf (_("not set\n"));
17569 return TRUE;
17570 }
17571
17572 switch (pnote->type)
17573 {
17574 case V850_NOTE_ALIGNMENT:
17575 switch (val)
17576 {
17577 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17578 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17579 }
17580 break;
17581
17582 case V850_NOTE_DATA_SIZE:
17583 switch (val)
17584 {
17585 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17586 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17587 }
17588 break;
17589
17590 case V850_NOTE_FPU_INFO:
17591 switch (val)
17592 {
17593 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17594 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17595 }
17596 break;
17597
17598 case V850_NOTE_MMU_INFO:
17599 case V850_NOTE_CACHE_INFO:
17600 case V850_NOTE_SIMD_INFO:
17601 if (val == EF_RH850_SIMD)
17602 {
17603 printf (_("yes\n"));
17604 return TRUE;
17605 }
17606 break;
17607
17608 default:
17609 /* An 'unknown note type' message will already have been displayed. */
17610 break;
17611 }
17612
17613 printf (_("unknown value: %x\n"), val);
17614 return FALSE;
17615}
17616
17617static bfd_boolean
17618process_netbsd_elf_note (Elf_Internal_Note * pnote)
17619{
17620 unsigned int version;
17621
17622 switch (pnote->type)
17623 {
17624 case NT_NETBSD_IDENT:
17625 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17626 if ((version / 10000) % 100)
17627 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17628 version, version / 100000000, (version / 1000000) % 100,
17629 (version / 10000) % 100 > 26 ? "Z" : "",
17630 'A' + (version / 10000) % 26);
17631 else
17632 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17633 version, version / 100000000, (version / 1000000) % 100,
17634 (version / 100) % 100);
17635 return TRUE;
17636
17637 case NT_NETBSD_MARCH:
17638 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17639 pnote->descdata);
17640 return TRUE;
17641
17642 default:
17643 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17644 pnote->type);
17645 return FALSE;
17646 }
17647}
17648
17649static const char *
17650get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17651{
17652 switch (e_type)
17653 {
17654 case NT_FREEBSD_THRMISC:
17655 return _("NT_THRMISC (thrmisc structure)");
17656 case NT_FREEBSD_PROCSTAT_PROC:
17657 return _("NT_PROCSTAT_PROC (proc data)");
17658 case NT_FREEBSD_PROCSTAT_FILES:
17659 return _("NT_PROCSTAT_FILES (files data)");
17660 case NT_FREEBSD_PROCSTAT_VMMAP:
17661 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17662 case NT_FREEBSD_PROCSTAT_GROUPS:
17663 return _("NT_PROCSTAT_GROUPS (groups data)");
17664 case NT_FREEBSD_PROCSTAT_UMASK:
17665 return _("NT_PROCSTAT_UMASK (umask data)");
17666 case NT_FREEBSD_PROCSTAT_RLIMIT:
17667 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17668 case NT_FREEBSD_PROCSTAT_OSREL:
17669 return _("NT_PROCSTAT_OSREL (osreldate data)");
17670 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17671 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17672 case NT_FREEBSD_PROCSTAT_AUXV:
17673 return _("NT_PROCSTAT_AUXV (auxv data)");
17674 case NT_FREEBSD_PTLWPINFO:
17675 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17676 }
17677 return get_note_type (filedata, e_type);
17678}
17679
17680static const char *
17681get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17682{
17683 static char buff[64];
17684
17685 if (e_type == NT_NETBSDCORE_PROCINFO)
17686 return _("NetBSD procinfo structure");
17687
17688 /* As of Jan 2002 there are no other machine-independent notes
17689 defined for NetBSD core files. If the note type is less
17690 than the start of the machine-dependent note types, we don't
17691 understand it. */
17692
17693 if (e_type < NT_NETBSDCORE_FIRSTMACH)
17694 {
17695 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17696 return buff;
17697 }
17698
17699 switch (filedata->file_header.e_machine)
17700 {
17701 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17702 and PT_GETFPREGS == mach+2. */
17703
17704 case EM_OLD_ALPHA:
17705 case EM_ALPHA:
17706 case EM_SPARC:
17707 case EM_SPARC32PLUS:
17708 case EM_SPARCV9:
17709 switch (e_type)
17710 {
17711 case NT_NETBSDCORE_FIRSTMACH + 0:
17712 return _("PT_GETREGS (reg structure)");
17713 case NT_NETBSDCORE_FIRSTMACH + 2:
17714 return _("PT_GETFPREGS (fpreg structure)");
17715 default:
17716 break;
17717 }
17718 break;
17719
17720 /* On all other arch's, PT_GETREGS == mach+1 and
17721 PT_GETFPREGS == mach+3. */
17722 default:
17723 switch (e_type)
17724 {
17725 case NT_NETBSDCORE_FIRSTMACH + 1:
17726 return _("PT_GETREGS (reg structure)");
17727 case NT_NETBSDCORE_FIRSTMACH + 3:
17728 return _("PT_GETFPREGS (fpreg structure)");
17729 default:
17730 break;
17731 }
17732 }
17733
17734 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17735 e_type - NT_NETBSDCORE_FIRSTMACH);
17736 return buff;
17737}
17738
17739static const char *
17740get_stapsdt_note_type (unsigned e_type)
17741{
17742 static char buff[64];
17743
17744 switch (e_type)
17745 {
17746 case NT_STAPSDT:
17747 return _("NT_STAPSDT (SystemTap probe descriptors)");
17748
17749 default:
17750 break;
17751 }
17752
17753 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17754 return buff;
17755}
17756
17757static bfd_boolean
17758print_stapsdt_note (Elf_Internal_Note *pnote)
17759{
17760 int addr_size = is_32bit_elf ? 4 : 8;
17761 char *data = pnote->descdata;
17762 char *data_end = pnote->descdata + pnote->descsz;
17763 bfd_vma pc, base_addr, semaphore;
17764 char *provider, *probe, *arg_fmt;
17765
17766 pc = byte_get ((unsigned char *) data, addr_size);
17767 data += addr_size;
17768 base_addr = byte_get ((unsigned char *) data, addr_size);
17769 data += addr_size;
17770 semaphore = byte_get ((unsigned char *) data, addr_size);
17771 data += addr_size;
17772
17773 provider = data;
17774 data += strlen (data) + 1;
17775 probe = data;
17776 data += strlen (data) + 1;
17777 arg_fmt = data;
17778 data += strlen (data) + 1;
17779
17780 printf (_(" Provider: %s\n"), provider);
17781 printf (_(" Name: %s\n"), probe);
17782 printf (_(" Location: "));
17783 print_vma (pc, FULL_HEX);
17784 printf (_(", Base: "));
17785 print_vma (base_addr, FULL_HEX);
17786 printf (_(", Semaphore: "));
17787 print_vma (semaphore, FULL_HEX);
17788 printf ("\n");
17789 printf (_(" Arguments: %s\n"), arg_fmt);
17790
17791 return data == data_end;
17792}
17793
17794static const char *
17795get_ia64_vms_note_type (unsigned e_type)
17796{
17797 static char buff[64];
17798
17799 switch (e_type)
17800 {
17801 case NT_VMS_MHD:
17802 return _("NT_VMS_MHD (module header)");
17803 case NT_VMS_LNM:
17804 return _("NT_VMS_LNM (language name)");
17805 case NT_VMS_SRC:
17806 return _("NT_VMS_SRC (source files)");
17807 case NT_VMS_TITLE:
17808 return "NT_VMS_TITLE";
17809 case NT_VMS_EIDC:
17810 return _("NT_VMS_EIDC (consistency check)");
17811 case NT_VMS_FPMODE:
17812 return _("NT_VMS_FPMODE (FP mode)");
17813 case NT_VMS_LINKTIME:
17814 return "NT_VMS_LINKTIME";
17815 case NT_VMS_IMGNAM:
17816 return _("NT_VMS_IMGNAM (image name)");
17817 case NT_VMS_IMGID:
17818 return _("NT_VMS_IMGID (image id)");
17819 case NT_VMS_LINKID:
17820 return _("NT_VMS_LINKID (link id)");
17821 case NT_VMS_IMGBID:
17822 return _("NT_VMS_IMGBID (build id)");
17823 case NT_VMS_GSTNAM:
17824 return _("NT_VMS_GSTNAM (sym table name)");
17825 case NT_VMS_ORIG_DYN:
17826 return "NT_VMS_ORIG_DYN";
17827 case NT_VMS_PATCHTIME:
17828 return "NT_VMS_PATCHTIME";
17829 default:
17830 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17831 return buff;
17832 }
17833}
17834
17835static bfd_boolean
17836print_ia64_vms_note (Elf_Internal_Note * pnote)
17837{
17838 switch (pnote->type)
17839 {
17840 case NT_VMS_MHD:
17841 if (pnote->descsz > 36)
17842 {
17843 size_t l = strlen (pnote->descdata + 34);
17844 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17845 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17846 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17847 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17848 }
17849 else
17850 printf (_(" Invalid size\n"));
17851 break;
17852 case NT_VMS_LNM:
17853 printf (_(" Language: %s\n"), pnote->descdata);
17854 break;
17855#ifdef BFD64
17856 case NT_VMS_FPMODE:
17857 printf (_(" Floating Point mode: "));
17858 printf ("0x%016" BFD_VMA_FMT "x\n",
17859 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17860 break;
17861 case NT_VMS_LINKTIME:
17862 printf (_(" Link time: "));
17863 print_vms_time
17864 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17865 printf ("\n");
17866 break;
17867 case NT_VMS_PATCHTIME:
17868 printf (_(" Patch time: "));
17869 print_vms_time
17870 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17871 printf ("\n");
17872 break;
17873 case NT_VMS_ORIG_DYN:
17874 printf (_(" Major id: %u, minor id: %u\n"),
17875 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17876 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17877 printf (_(" Last modified : "));
17878 print_vms_time
17879 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17880 printf (_("\n Link flags : "));
17881 printf ("0x%016" BFD_VMA_FMT "x\n",
17882 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17883 printf (_(" Header flags: 0x%08x\n"),
17884 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17885 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17886 break;
17887#endif
17888 case NT_VMS_IMGNAM:
17889 printf (_(" Image name: %s\n"), pnote->descdata);
17890 break;
17891 case NT_VMS_GSTNAM:
17892 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17893 break;
17894 case NT_VMS_IMGID:
17895 printf (_(" Image id: %s\n"), pnote->descdata);
17896 break;
17897 case NT_VMS_LINKID:
17898 printf (_(" Linker id: %s\n"), pnote->descdata);
17899 break;
17900 default:
17901 return FALSE;
17902 }
17903 return TRUE;
17904}
17905
17906/* Find the symbol associated with a build attribute that is attached
17907 to address OFFSET. If PNAME is non-NULL then store the name of
17908 the symbol (if found) in the provided pointer, Returns NULL if a
17909 symbol could not be found. */
17910
17911static Elf_Internal_Sym *
17912get_symbol_for_build_attribute (Filedata * filedata,
17913 unsigned long offset,
17914 bfd_boolean is_open_attr,
17915 const char ** pname)
17916{
17917 static Filedata * saved_filedata = NULL;
17918 static char * strtab;
17919 static unsigned long strtablen;
17920 static Elf_Internal_Sym * symtab;
17921 static unsigned long nsyms;
17922 Elf_Internal_Sym * saved_sym = NULL;
17923 Elf_Internal_Sym * sym;
17924
17925 if (filedata->section_headers != NULL
17926 && (saved_filedata == NULL || filedata != saved_filedata))
17927 {
17928 Elf_Internal_Shdr * symsec;
17929
17930 /* Load the symbol and string sections. */
17931 for (symsec = filedata->section_headers;
17932 symsec < filedata->section_headers + filedata->file_header.e_shnum;
17933 symsec ++)
17934 {
17935 if (symsec->sh_type == SHT_SYMTAB)
17936 {
17937 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17938
17939 if (symsec->sh_link < filedata->file_header.e_shnum)
17940 {
17941 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17942
17943 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17944 1, strtab_sec->sh_size,
17945 _("string table"));
17946 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17947 }
17948 }
17949 }
17950 saved_filedata = filedata;
17951 }
17952
17953 if (symtab == NULL || strtab == NULL)
17954 return NULL;
17955
17956 /* Find a symbol whose value matches offset. */
17957 for (sym = symtab; sym < symtab + nsyms; sym ++)
17958 if (sym->st_value == offset)
17959 {
17960 if (sym->st_name >= strtablen)
17961 /* Huh ? This should not happen. */
17962 continue;
17963
17964 if (strtab[sym->st_name] == 0)
17965 continue;
17966
17967 /* The AArch64 and ARM architectures define mapping symbols
17968 (eg $d, $x, $t) which we want to ignore. */
17969 if (strtab[sym->st_name] == '$'
17970 && strtab[sym->st_name + 1] != 0
17971 && strtab[sym->st_name + 2] == 0)
17972 continue;
17973
17974 if (is_open_attr)
17975 {
17976 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17977 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17978 FUNC symbols entirely. */
17979 switch (ELF_ST_TYPE (sym->st_info))
17980 {
17981 case STT_OBJECT:
17982 case STT_FILE:
17983 saved_sym = sym;
17984 if (sym->st_size)
17985 {
17986 /* If the symbol has a size associated
17987 with it then we can stop searching. */
17988 sym = symtab + nsyms;
17989 }
17990 continue;
17991
17992 case STT_FUNC:
17993 /* Ignore function symbols. */
17994 continue;
17995
17996 default:
17997 break;
17998 }
17999
18000 switch (ELF_ST_BIND (sym->st_info))
18001 {
18002 case STB_GLOBAL:
18003 if (saved_sym == NULL
18004 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18005 saved_sym = sym;
18006 break;
18007
18008 case STB_LOCAL:
18009 if (saved_sym == NULL)
18010 saved_sym = sym;
18011 break;
18012
18013 default:
18014 break;
18015 }
18016 }
18017 else
18018 {
18019 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18020 continue;
18021
18022 saved_sym = sym;
18023 break;
18024 }
18025 }
18026
18027 if (saved_sym && pname)
18028 * pname = strtab + saved_sym->st_name;
18029
18030 return saved_sym;
18031}
18032
18033/* Returns true iff addr1 and addr2 are in the same section. */
18034
18035static bfd_boolean
18036same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18037{
18038 Elf_Internal_Shdr * a1;
18039 Elf_Internal_Shdr * a2;
18040
18041 a1 = find_section_by_address (filedata, addr1);
18042 a2 = find_section_by_address (filedata, addr2);
18043
18044 return a1 == a2 && a1 != NULL;
18045}
18046
18047static bfd_boolean
18048print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18049 Filedata * filedata)
18050{
18051 static unsigned long global_offset = 0;
18052 static unsigned long global_end = 0;
18053 static unsigned long func_offset = 0;
18054 static unsigned long func_end = 0;
18055
18056 Elf_Internal_Sym * sym;
18057 const char * name;
18058 unsigned long start;
18059 unsigned long end;
18060 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18061
18062 switch (pnote->descsz)
18063 {
18064 case 0:
18065 /* A zero-length description means that the range of
18066 the previous note of the same type should be used. */
18067 if (is_open_attr)
18068 {
18069 if (global_end > global_offset)
18070 printf (_(" Applies to region from %#lx to %#lx\n"),
18071 global_offset, global_end);
18072 else
18073 printf (_(" Applies to region from %#lx\n"), global_offset);
18074 }
18075 else
18076 {
18077 if (func_end > func_offset)
18078 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18079 else
18080 printf (_(" Applies to region from %#lx\n"), func_offset);
18081 }
18082 return TRUE;
18083
18084 case 4:
18085 start = byte_get ((unsigned char *) pnote->descdata, 4);
18086 end = 0;
18087 break;
18088
18089 case 8:
18090 if (is_32bit_elf)
18091 {
18092 /* FIXME: We should check that version 3+ notes are being used here... */
18093 start = byte_get ((unsigned char *) pnote->descdata, 4);
18094 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18095 }
18096 else
18097 {
18098 start = byte_get ((unsigned char *) pnote->descdata, 8);
18099 end = 0;
18100 }
18101 break;
18102
18103 case 16:
18104 start = byte_get ((unsigned char *) pnote->descdata, 8);
18105 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18106 break;
18107
18108 default:
18109 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18110 printf (_(" <invalid descsz>"));
18111 return FALSE;
18112 }
18113
18114 name = NULL;
18115 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18116 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18117 in order to avoid them being confused with the start address of the
18118 first function in the file... */
18119 if (sym == NULL && is_open_attr)
18120 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18121 & name);
18122
18123 if (end == 0 && sym != NULL && sym->st_size > 0)
18124 end = start + sym->st_size;
18125
18126 if (is_open_attr)
18127 {
18128 /* FIXME: Need to properly allow for section alignment.
18129 16 is just the alignment used on x86_64. */
18130 if (global_end > 0
18131 && start > BFD_ALIGN (global_end, 16)
18132 /* Build notes are not guaranteed to be organised in order of
18133 increasing address, but we should find the all of the notes
18134 for one section in the same place. */
18135 && same_section (filedata, start, global_end))
18136 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18137 global_end + 1, start - 1);
18138
18139 printf (_(" Applies to region from %#lx"), start);
18140 global_offset = start;
18141
18142 if (end)
18143 {
18144 printf (_(" to %#lx"), end);
18145 global_end = end;
18146 }
18147 }
18148 else
18149 {
18150 printf (_(" Applies to region from %#lx"), start);
18151 func_offset = start;
18152
18153 if (end)
18154 {
18155 printf (_(" to %#lx"), end);
18156 func_end = end;
18157 }
18158 }
18159
18160 if (sym && name)
18161 printf (_(" (%s)"), name);
18162
18163 printf ("\n");
18164 return TRUE;
18165}
18166
18167static bfd_boolean
18168print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18169{
18170 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18171 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18172 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18173 char name_type;
18174 char name_attribute;
18175 const char * expected_types;
18176 const char * name = pnote->namedata;
18177 const char * text;
18178 signed int left;
18179
18180 if (name == NULL || pnote->namesz < 2)
18181 {
18182 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18183 print_symbol (-20, _(" <corrupt name>"));
18184 return FALSE;
18185 }
18186
18187 if (do_wide)
18188 left = 28;
18189 else
18190 left = 20;
18191
18192 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18193 if (name[0] == 'G' && name[1] == 'A')
18194 {
18195 if (pnote->namesz < 4)
18196 {
18197 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18198 print_symbol (-20, _(" <corrupt name>"));
18199 return FALSE;
18200 }
18201
18202 printf ("GA");
18203 name += 2;
18204 left -= 2;
18205 }
18206
18207 switch ((name_type = * name))
18208 {
18209 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18210 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18211 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18212 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18213 printf ("%c", * name);
18214 left --;
18215 break;
18216 default:
18217 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18218 print_symbol (-20, _("<unknown name type>"));
18219 return FALSE;
18220 }
18221
18222 ++ name;
18223 text = NULL;
18224
18225 switch ((name_attribute = * name))
18226 {
18227 case GNU_BUILD_ATTRIBUTE_VERSION:
18228 text = _("<version>");
18229 expected_types = string_expected;
18230 ++ name;
18231 break;
18232 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18233 text = _("<stack prot>");
18234 expected_types = "!+*";
18235 ++ name;
18236 break;
18237 case GNU_BUILD_ATTRIBUTE_RELRO:
18238 text = _("<relro>");
18239 expected_types = bool_expected;
18240 ++ name;
18241 break;
18242 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18243 text = _("<stack size>");
18244 expected_types = number_expected;
18245 ++ name;
18246 break;
18247 case GNU_BUILD_ATTRIBUTE_TOOL:
18248 text = _("<tool>");
18249 expected_types = string_expected;
18250 ++ name;
18251 break;
18252 case GNU_BUILD_ATTRIBUTE_ABI:
18253 text = _("<ABI>");
18254 expected_types = "$*";
18255 ++ name;
18256 break;
18257 case GNU_BUILD_ATTRIBUTE_PIC:
18258 text = _("<PIC>");
18259 expected_types = number_expected;
18260 ++ name;
18261 break;
18262 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18263 text = _("<short enum>");
18264 expected_types = bool_expected;
18265 ++ name;
18266 break;
18267 default:
18268 if (ISPRINT (* name))
18269 {
18270 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18271
18272 if (len > left && ! do_wide)
18273 len = left;
18274 printf ("%.*s:", len, name);
18275 left -= len;
18276 name += len;
18277 }
18278 else
18279 {
18280 static char tmpbuf [128];
18281
18282 error (_("unrecognised byte in name field: %d\n"), * name);
18283 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18284 text = tmpbuf;
18285 name ++;
18286 }
18287 expected_types = "*$!+";
18288 break;
18289 }
18290
18291 if (text)
18292 left -= printf ("%s", text);
18293
18294 if (strchr (expected_types, name_type) == NULL)
18295 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18296
18297 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18298 {
18299 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18300 (unsigned long) pnote->namesz,
18301 (long) (name - pnote->namedata));
18302 return FALSE;
18303 }
18304
18305 if (left < 1 && ! do_wide)
18306 return TRUE;
18307
18308 switch (name_type)
18309 {
18310 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18311 {
18312 unsigned int bytes;
18313 unsigned long long val = 0;
18314 unsigned int shift = 0;
18315 char * decoded = NULL;
18316
18317 bytes = pnote->namesz - (name - pnote->namedata);
18318 if (bytes > 0)
18319 /* The -1 is because the name field is always 0 terminated, and we
18320 want to be able to ensure that the shift in the while loop below
18321 will not overflow. */
18322 -- bytes;
18323
18324 if (bytes > sizeof (val))
18325 {
18326 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18327 bytes);
18328 bytes = sizeof (val);
18329 }
18330 /* We do not bother to warn if bytes == 0 as this can
18331 happen with some early versions of the gcc plugin. */
18332
18333 while (bytes --)
18334 {
18335 unsigned long byte = (* name ++) & 0xff;
18336
18337 val |= byte << shift;
18338 shift += 8;
18339 }
18340
18341 switch (name_attribute)
18342 {
18343 case GNU_BUILD_ATTRIBUTE_PIC:
18344 switch (val)
18345 {
18346 case 0: decoded = "static"; break;
18347 case 1: decoded = "pic"; break;
18348 case 2: decoded = "PIC"; break;
18349 case 3: decoded = "pie"; break;
18350 case 4: decoded = "PIE"; break;
18351 default: break;
18352 }
18353 break;
18354 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18355 switch (val)
18356 {
18357 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18358 case 0: decoded = "off"; break;
18359 case 1: decoded = "on"; break;
18360 case 2: decoded = "all"; break;
18361 case 3: decoded = "strong"; break;
18362 case 4: decoded = "explicit"; break;
18363 default: break;
18364 }
18365 break;
18366 default:
18367 break;
18368 }
18369
18370 if (decoded != NULL)
18371 {
18372 print_symbol (-left, decoded);
18373 left = 0;
18374 }
18375 else if (val == 0)
18376 {
18377 printf ("0x0");
18378 left -= 3;
18379 }
18380 else
18381 {
18382 if (do_wide)
18383 left -= printf ("0x%llx", val);
18384 else
18385 left -= printf ("0x%-.*llx", left, val);
18386 }
18387 }
18388 break;
18389 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18390 left -= print_symbol (- left, name);
18391 break;
18392 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18393 left -= print_symbol (- left, "true");
18394 break;
18395 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18396 left -= print_symbol (- left, "false");
18397 break;
18398 }
18399
18400 if (do_wide && left > 0)
18401 printf ("%-*s", left, " ");
18402
18403 return TRUE;
18404}
18405
18406/* Note that by the ELF standard, the name field is already null byte
18407 terminated, and namesz includes the terminating null byte.
18408 I.E. the value of namesz for the name "FSF" is 4.
18409
18410 If the value of namesz is zero, there is no name present. */
18411
18412static bfd_boolean
18413process_note (Elf_Internal_Note * pnote,
18414 Filedata * filedata)
18415{
18416 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18417 const char * nt;
18418
18419 if (pnote->namesz == 0)
18420 /* If there is no note name, then use the default set of
18421 note type strings. */
18422 nt = get_note_type (filedata, pnote->type);
18423
18424 else if (const_strneq (pnote->namedata, "GNU"))
18425 /* GNU-specific object file notes. */
18426 nt = get_gnu_elf_note_type (pnote->type);
18427
18428 else if (const_strneq (pnote->namedata, "FreeBSD"))
18429 /* FreeBSD-specific core file notes. */
18430 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18431
18432 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18433 /* NetBSD-specific core file notes. */
18434 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18435
18436 else if (const_strneq (pnote->namedata, "NetBSD"))
18437 /* NetBSD-specific core file notes. */
18438 return process_netbsd_elf_note (pnote);
18439
18440 else if (strneq (pnote->namedata, "SPU/", 4))
18441 {
18442 /* SPU-specific core file notes. */
18443 nt = pnote->namedata + 4;
18444 name = "SPU";
18445 }
18446
18447 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18448 /* VMS/ia64-specific file notes. */
18449 nt = get_ia64_vms_note_type (pnote->type);
18450
18451 else if (const_strneq (pnote->namedata, "stapsdt"))
18452 nt = get_stapsdt_note_type (pnote->type);
18453
18454 else
18455 /* Don't recognize this note name; just use the default set of
18456 note type strings. */
18457 nt = get_note_type (filedata, pnote->type);
18458
18459 printf (" ");
18460
18461 if (((const_strneq (pnote->namedata, "GA")
18462 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18463 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18464 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18465 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18466 print_gnu_build_attribute_name (pnote);
18467 else
18468 print_symbol (-20, name);
18469
18470 if (do_wide)
18471 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18472 else
18473 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18474
18475 if (const_strneq (pnote->namedata, "IPF/VMS"))
18476 return print_ia64_vms_note (pnote);
18477 else if (const_strneq (pnote->namedata, "GNU"))
18478 return print_gnu_note (filedata, pnote);
18479 else if (const_strneq (pnote->namedata, "stapsdt"))
18480 return print_stapsdt_note (pnote);
18481 else if (const_strneq (pnote->namedata, "CORE"))
18482 return print_core_note (pnote);
18483 else if (((const_strneq (pnote->namedata, "GA")
18484 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18485 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18486 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18487 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18488 return print_gnu_build_attribute_description (pnote, filedata);
18489
18490 if (pnote->descsz)
18491 {
18492 unsigned long i;
18493
18494 printf (_(" description data: "));
18495 for (i = 0; i < pnote->descsz; i++)
18496 printf ("%02x ", pnote->descdata[i]);
18497 if (!do_wide)
18498 printf ("\n");
18499 }
18500
18501 if (do_wide)
18502 printf ("\n");
18503
18504 return TRUE;
18505}
18506
18507static bfd_boolean
18508process_notes_at (Filedata * filedata,
18509 Elf_Internal_Shdr * section,
18510 bfd_vma offset,
18511 bfd_vma length,
18512 bfd_vma align)
18513{
18514 Elf_External_Note * pnotes;
18515 Elf_External_Note * external;
18516 char * end;
18517 bfd_boolean res = TRUE;
18518
18519 if (length <= 0)
18520 return FALSE;
18521
18522 if (section)
18523 {
18524 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18525 if (pnotes)
18526 {
18527 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18528 return FALSE;
18529 }
18530 }
18531 else
18532 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18533 _("notes"));
18534
18535 if (pnotes == NULL)
18536 return FALSE;
18537
18538 external = pnotes;
18539
18540 if (section)
18541 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18542 else
18543 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18544 (unsigned long) offset, (unsigned long) length);
18545
18546 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18547 specifies that notes should be aligned to 4 bytes in 32-bit
18548 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18549 we also support 4 byte alignment in 64-bit objects. If section
18550 alignment is less than 4, we treate alignment as 4 bytes. */
18551 if (align < 4)
18552 align = 4;
18553 else if (align != 4 && align != 8)
18554 {
18555 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18556 (long) align);
18557 return FALSE;
18558 }
18559
18560 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18561
18562 end = (char *) pnotes + length;
18563 while ((char *) external < end)
18564 {
18565 Elf_Internal_Note inote;
18566 size_t min_notesz;
18567 char * next;
18568 char * temp = NULL;
18569 size_t data_remaining = end - (char *) external;
18570
18571 if (!is_ia64_vms (filedata))
18572 {
18573 /* PR binutils/15191
18574 Make sure that there is enough data to read. */
18575 min_notesz = offsetof (Elf_External_Note, name);
18576 if (data_remaining < min_notesz)
18577 {
18578 warn (ngettext ("Corrupt note: only %ld byte remains, "
18579 "not enough for a full note\n",
18580 "Corrupt note: only %ld bytes remain, "
18581 "not enough for a full note\n",
18582 data_remaining),
18583 (long) data_remaining);
18584 break;
18585 }
18586 data_remaining -= min_notesz;
18587
18588 inote.type = BYTE_GET (external->type);
18589 inote.namesz = BYTE_GET (external->namesz);
18590 inote.namedata = external->name;
18591 inote.descsz = BYTE_GET (external->descsz);
18592 inote.descdata = ((char *) external
18593 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18594 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18595 next = ((char *) external
18596 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18597 }
18598 else
18599 {
18600 Elf64_External_VMS_Note *vms_external;
18601
18602 /* PR binutils/15191
18603 Make sure that there is enough data to read. */
18604 min_notesz = offsetof (Elf64_External_VMS_Note, name);
18605 if (data_remaining < min_notesz)
18606 {
18607 warn (ngettext ("Corrupt note: only %ld byte remains, "
18608 "not enough for a full note\n",
18609 "Corrupt note: only %ld bytes remain, "
18610 "not enough for a full note\n",
18611 data_remaining),
18612 (long) data_remaining);
18613 break;
18614 }
18615 data_remaining -= min_notesz;
18616
18617 vms_external = (Elf64_External_VMS_Note *) external;
18618 inote.type = BYTE_GET (vms_external->type);
18619 inote.namesz = BYTE_GET (vms_external->namesz);
18620 inote.namedata = vms_external->name;
18621 inote.descsz = BYTE_GET (vms_external->descsz);
18622 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18623 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18624 next = inote.descdata + align_power (inote.descsz, 3);
18625 }
18626
18627 /* PR 17531: file: 3443835e. */
18628 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18629 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18630 || (size_t) (inote.descdata - inote.namedata) > data_remaining
18631 || (size_t) (next - inote.descdata) < inote.descsz
18632 || ((size_t) (next - inote.descdata)
18633 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18634 {
18635 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18636 (unsigned long) ((char *) external - (char *) pnotes));
18637 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18638 inote.type, inote.namesz, inote.descsz, (int) align);
18639 break;
18640 }
18641
18642 external = (Elf_External_Note *) next;
18643
18644 /* Verify that name is null terminated. It appears that at least
18645 one version of Linux (RedHat 6.0) generates corefiles that don't
18646 comply with the ELF spec by failing to include the null byte in
18647 namesz. */
18648 if (inote.namedata[inote.namesz - 1] != '\0')
18649 {
18650 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18651 {
18652 temp = (char *) malloc (inote.namesz + 1);
18653 if (temp == NULL)
18654 {
18655 error (_("Out of memory allocating space for inote name\n"));
18656 res = FALSE;
18657 break;
18658 }
18659
18660 memcpy (temp, inote.namedata, inote.namesz);
18661 inote.namedata = temp;
18662 }
18663 inote.namedata[inote.namesz] = 0;
18664 }
18665
18666 if (! process_note (& inote, filedata))
18667 res = FALSE;
18668
18669 if (temp != NULL)
18670 {
18671 free (temp);
18672 temp = NULL;
18673 }
18674 }
18675
18676 free (pnotes);
18677
18678 return res;
18679}
18680
18681static bfd_boolean
18682process_corefile_note_segments (Filedata * filedata)
18683{
18684 Elf_Internal_Phdr * segment;
18685 unsigned int i;
18686 bfd_boolean res = TRUE;
18687
18688 if (! get_program_headers (filedata))
18689 return TRUE;
18690
18691 for (i = 0, segment = filedata->program_headers;
18692 i < filedata->file_header.e_phnum;
18693 i++, segment++)
18694 {
18695 if (segment->p_type == PT_NOTE)
18696 if (! process_notes_at (filedata, NULL,
18697 (bfd_vma) segment->p_offset,
18698 (bfd_vma) segment->p_filesz,
18699 (bfd_vma) segment->p_align))
18700 res = FALSE;
18701 }
18702
18703 return res;
18704}
18705
18706static bfd_boolean
18707process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18708{
18709 Elf_External_Note * pnotes;
18710 Elf_External_Note * external;
18711 char * end;
18712 bfd_boolean res = TRUE;
18713
18714 if (length <= 0)
18715 return FALSE;
18716
18717 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18718 _("v850 notes"));
18719 if (pnotes == NULL)
18720 return FALSE;
18721
18722 external = pnotes;
18723 end = (char*) pnotes + length;
18724
18725 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18726 (unsigned long) offset, (unsigned long) length);
18727
18728 while ((char *) external + sizeof (Elf_External_Note) < end)
18729 {
18730 Elf_External_Note * next;
18731 Elf_Internal_Note inote;
18732
18733 inote.type = BYTE_GET (external->type);
18734 inote.namesz = BYTE_GET (external->namesz);
18735 inote.namedata = external->name;
18736 inote.descsz = BYTE_GET (external->descsz);
18737 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18738 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18739
18740 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18741 {
18742 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18743 inote.descdata = inote.namedata;
18744 inote.namesz = 0;
18745 }
18746
18747 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18748
18749 if ( ((char *) next > end)
18750 || ((char *) next < (char *) pnotes))
18751 {
18752 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18753 (unsigned long) ((char *) external - (char *) pnotes));
18754 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18755 inote.type, inote.namesz, inote.descsz);
18756 break;
18757 }
18758
18759 external = next;
18760
18761 /* Prevent out-of-bounds indexing. */
18762 if ( inote.namedata + inote.namesz > end
18763 || inote.namedata + inote.namesz < inote.namedata)
18764 {
18765 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18766 (unsigned long) ((char *) external - (char *) pnotes));
18767 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18768 inote.type, inote.namesz, inote.descsz);
18769 break;
18770 }
18771
18772 printf (" %s: ", get_v850_elf_note_type (inote.type));
18773
18774 if (! print_v850_note (& inote))
18775 {
18776 res = FALSE;
18777 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18778 inote.namesz, inote.descsz);
18779 }
18780 }
18781
18782 free (pnotes);
18783
18784 return res;
18785}
18786
18787static bfd_boolean
18788process_note_sections (Filedata * filedata)
18789{
18790 Elf_Internal_Shdr * section;
18791 unsigned long i;
18792 unsigned int n = 0;
18793 bfd_boolean res = TRUE;
18794
18795 for (i = 0, section = filedata->section_headers;
18796 i < filedata->file_header.e_shnum && section != NULL;
18797 i++, section++)
18798 {
18799 if (section->sh_type == SHT_NOTE)
18800 {
18801 if (! process_notes_at (filedata, section,
18802 (bfd_vma) section->sh_offset,
18803 (bfd_vma) section->sh_size,
18804 (bfd_vma) section->sh_addralign))
18805 res = FALSE;
18806 n++;
18807 }
18808
18809 if (( filedata->file_header.e_machine == EM_V800
18810 || filedata->file_header.e_machine == EM_V850
18811 || filedata->file_header.e_machine == EM_CYGNUS_V850)
18812 && section->sh_type == SHT_RENESAS_INFO)
18813 {
18814 if (! process_v850_notes (filedata,
18815 (bfd_vma) section->sh_offset,
18816 (bfd_vma) section->sh_size))
18817 res = FALSE;
18818 n++;
18819 }
18820 }
18821
18822 if (n == 0)
18823 /* Try processing NOTE segments instead. */
18824 return process_corefile_note_segments (filedata);
18825
18826 return res;
18827}
18828
18829static bfd_boolean
18830process_notes (Filedata * filedata)
18831{
18832 /* If we have not been asked to display the notes then do nothing. */
18833 if (! do_notes)
18834 return TRUE;
18835
18836 if (filedata->file_header.e_type != ET_CORE)
18837 return process_note_sections (filedata);
18838
18839 /* No program headers means no NOTE segment. */
18840 if (filedata->file_header.e_phnum > 0)
18841 return process_corefile_note_segments (filedata);
18842
18843 printf (_("No note segments present in the core file.\n"));
18844 return TRUE;
18845}
18846
18847static unsigned char *
18848display_public_gnu_attributes (unsigned char * start,
18849 const unsigned char * const end)
18850{
18851 printf (_(" Unknown GNU attribute: %s\n"), start);
18852
18853 start += strnlen ((char *) start, end - start);
18854 display_raw_attribute (start, end);
18855
18856 return (unsigned char *) end;
18857}
18858
18859static unsigned char *
18860display_generic_attribute (unsigned char * start,
18861 unsigned int tag,
18862 const unsigned char * const end)
18863{
18864 if (tag == 0)
18865 return (unsigned char *) end;
18866
18867 return display_tag_value (tag, start, end);
18868}
18869
18870static bfd_boolean
18871process_arch_specific (Filedata * filedata)
18872{
18873 if (! do_arch)
18874 return TRUE;
18875
18876 switch (filedata->file_header.e_machine)
18877 {
18878 case EM_ARC:
18879 case EM_ARC_COMPACT:
18880 case EM_ARC_COMPACT2:
18881 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18882 display_arc_attribute,
18883 display_generic_attribute);
18884 case EM_ARM:
18885 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18886 display_arm_attribute,
18887 display_generic_attribute);
18888
18889 case EM_MIPS:
18890 case EM_MIPS_RS3_LE:
18891 return process_mips_specific (filedata);
18892
18893 case EM_MSP430:
18894 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18895 display_msp430x_attribute,
18896 display_generic_attribute);
18897
18898 case EM_NDS32:
18899 return process_nds32_specific (filedata);
18900
18901 case EM_PPC:
18902 case EM_PPC64:
18903 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18904 display_power_gnu_attribute);
18905
18906 case EM_S390:
18907 case EM_S390_OLD:
18908 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18909 display_s390_gnu_attribute);
18910
18911 case EM_SPARC:
18912 case EM_SPARC32PLUS:
18913 case EM_SPARCV9:
18914 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18915 display_sparc_gnu_attribute);
18916
18917 case EM_TI_C6000:
18918 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18919 display_tic6x_attribute,
18920 display_generic_attribute);
18921
18922 default:
18923 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18924 display_public_gnu_attributes,
18925 display_generic_attribute);
18926 }
18927}
18928
18929static bfd_boolean
18930get_file_header (Filedata * filedata)
18931{
18932 /* Read in the identity array. */
18933 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18934 return FALSE;
18935
18936 /* Determine how to read the rest of the header. */
18937 switch (filedata->file_header.e_ident[EI_DATA])
18938 {
18939 default:
18940 case ELFDATANONE:
18941 case ELFDATA2LSB:
18942 byte_get = byte_get_little_endian;
18943 byte_put = byte_put_little_endian;
18944 break;
18945 case ELFDATA2MSB:
18946 byte_get = byte_get_big_endian;
18947 byte_put = byte_put_big_endian;
18948 break;
18949 }
18950
18951 /* For now we only support 32 bit and 64 bit ELF files. */
18952 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18953
18954 /* Read in the rest of the header. */
18955 if (is_32bit_elf)
18956 {
18957 Elf32_External_Ehdr ehdr32;
18958
18959 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18960 return FALSE;
18961
18962 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
18963 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
18964 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
18965 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
18966 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18967 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18968 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
18969 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18970 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18971 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18972 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18973 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18974 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18975 }
18976 else
18977 {
18978 Elf64_External_Ehdr ehdr64;
18979
18980 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18981 we will not be able to cope with the 64bit data found in
18982 64 ELF files. Detect this now and abort before we start
18983 overwriting things. */
18984 if (sizeof (bfd_vma) < 8)
18985 {
18986 error (_("This instance of readelf has been built without support for a\n\
1898764 bit data type and so it cannot read 64 bit ELF files.\n"));
18988 return FALSE;
18989 }
18990
18991 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18992 return FALSE;
18993
18994 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
18995 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
18996 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
18997 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
18998 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18999 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19000 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19001 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19002 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19003 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19004 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19005 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19006 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19007 }
19008
19009 if (filedata->file_header.e_shoff)
19010 {
19011 /* There may be some extensions in the first section header. Don't
19012 bomb if we can't read it. */
19013 if (is_32bit_elf)
19014 get_32bit_section_headers (filedata, TRUE);
19015 else
19016 get_64bit_section_headers (filedata, TRUE);
19017 }
19018
19019 return TRUE;
19020}
19021
19022static void
19023close_file (Filedata * filedata)
19024{
19025 if (filedata)
19026 {
19027 if (filedata->handle)
19028 fclose (filedata->handle);
19029 free (filedata);
19030 }
19031}
19032
19033void
19034close_debug_file (void * data)
19035{
19036 close_file ((Filedata *) data);
19037}
19038
19039static Filedata *
19040open_file (const char * pathname)
19041{
19042 struct stat statbuf;
19043 Filedata * filedata = NULL;
19044
19045 if (stat (pathname, & statbuf) < 0
19046 || ! S_ISREG (statbuf.st_mode))
19047 goto fail;
19048
19049 filedata = calloc (1, sizeof * filedata);
19050 if (filedata == NULL)
19051 goto fail;
19052
19053 filedata->handle = fopen (pathname, "rb");
19054 if (filedata->handle == NULL)
19055 goto fail;
19056
19057 filedata->file_size = (bfd_size_type) statbuf.st_size;
19058 filedata->file_name = pathname;
19059
19060 if (! get_file_header (filedata))
19061 goto fail;
19062
19063 if (filedata->file_header.e_shoff)
19064 {
19065 bfd_boolean res;
19066
19067 /* Read the section headers again, this time for real. */
19068 if (is_32bit_elf)
19069 res = get_32bit_section_headers (filedata, FALSE);
19070 else
19071 res = get_64bit_section_headers (filedata, FALSE);
19072
19073 if (!res)
19074 goto fail;
19075 }
19076
19077 return filedata;
19078
19079 fail:
19080 if (filedata)
19081 {
19082 if (filedata->handle)
19083 fclose (filedata->handle);
19084 free (filedata);
19085 }
19086 return NULL;
19087}
19088
19089void *
19090open_debug_file (const char * pathname)
19091{
19092 return open_file (pathname);
19093}
19094
19095/* Process one ELF object file according to the command line options.
19096 This file may actually be stored in an archive. The file is
19097 positioned at the start of the ELF object. Returns TRUE if no
19098 problems were encountered, FALSE otherwise. */
19099
19100static bfd_boolean
19101process_object (Filedata * filedata)
19102{
19103 Filedata * separates;
19104 unsigned int i;
19105 bfd_boolean res = TRUE;
19106
19107 if (! get_file_header (filedata))
19108 {
19109 error (_("%s: Failed to read file header\n"), filedata->file_name);
19110 return FALSE;
19111 }
19112
19113 /* Initialise per file variables. */
19114 for (i = ARRAY_SIZE (version_info); i--;)
19115 version_info[i] = 0;
19116
19117 for (i = ARRAY_SIZE (dynamic_info); i--;)
19118 dynamic_info[i] = 0;
19119 dynamic_info_DT_GNU_HASH = 0;
19120
19121 /* Process the file. */
19122 if (show_name)
19123 printf (_("\nFile: %s\n"), filedata->file_name);
19124
19125 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19126 Note we do this even if cmdline_dump_sects is empty because we
19127 must make sure that the dump_sets array is zeroed out before each
19128 object file is processed. */
19129 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19130 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19131
19132 if (cmdline.num_dump_sects > 0)
19133 {
19134 if (filedata->num_dump_sects == 0)
19135 /* A sneaky way of allocating the dump_sects array. */
19136 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19137
19138 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19139 memcpy (filedata->dump_sects, cmdline.dump_sects,
19140 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19141 }
19142
19143 if (! process_file_header (filedata))
19144 return FALSE;
19145
19146 if (! process_section_headers (filedata))
19147 {
19148 /* Without loaded section headers we cannot process lots of things. */
19149 do_unwind = do_version = do_dump = do_arch = FALSE;
19150
19151 if (! do_using_dynamic)
19152 do_syms = do_dyn_syms = do_reloc = FALSE;
19153 }
19154
19155 if (! process_section_groups (filedata))
19156 /* Without loaded section groups we cannot process unwind. */
19157 do_unwind = FALSE;
19158
19159 if (process_program_headers (filedata))
19160 process_dynamic_section (filedata);
19161 else
19162 res = FALSE;
19163
19164 if (! process_relocs (filedata))
19165 res = FALSE;
19166
19167 if (! process_unwind (filedata))
19168 res = FALSE;
19169
19170 if (! process_symbol_table (filedata))
19171 res = FALSE;
19172
19173 if (! process_syminfo (filedata))
19174 res = FALSE;
19175
19176 if (! process_version_sections (filedata))
19177 res = FALSE;
19178
19179 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19180 separates = load_separate_debug_file (filedata, filedata->file_name);
19181 else
19182 separates = NULL;
19183
19184 if (! process_section_contents (filedata))
19185 res = FALSE;
19186
19187 if (separates)
19188 {
19189 if (! process_section_headers (separates))
19190 res = FALSE;
19191 else if (! process_section_contents (separates))
19192 res = FALSE;
19193 }
19194
19195 if (! process_notes (filedata))
19196 res = FALSE;
19197
19198 if (! process_gnu_liblist (filedata))
19199 res = FALSE;
19200
19201 if (! process_arch_specific (filedata))
19202 res = FALSE;
19203
19204 free (filedata->program_headers);
19205 filedata->program_headers = NULL;
19206
19207 free (filedata->section_headers);
19208 filedata->section_headers = NULL;
19209
19210 free (filedata->string_table);
19211 filedata->string_table = NULL;
19212 filedata->string_table_length = 0;
19213
19214 if (dynamic_strings)
19215 {
19216 free (dynamic_strings);
19217 dynamic_strings = NULL;
19218 dynamic_strings_length = 0;
19219 }
19220
19221 if (dynamic_symbols)
19222 {
19223 free (dynamic_symbols);
19224 dynamic_symbols = NULL;
19225 num_dynamic_syms = 0;
19226 }
19227
19228 if (dynamic_syminfo)
19229 {
19230 free (dynamic_syminfo);
19231 dynamic_syminfo = NULL;
19232 }
19233
19234 if (dynamic_section)
19235 {
19236 free (dynamic_section);
19237 dynamic_section = NULL;
19238 }
19239
19240 if (section_headers_groups)
19241 {
19242 free (section_headers_groups);
19243 section_headers_groups = NULL;
19244 }
19245
19246 if (section_groups)
19247 {
19248 struct group_list * g;
19249 struct group_list * next;
19250
19251 for (i = 0; i < group_count; i++)
19252 {
19253 for (g = section_groups [i].root; g != NULL; g = next)
19254 {
19255 next = g->next;
19256 free (g);
19257 }
19258 }
19259
19260 free (section_groups);
19261 section_groups = NULL;
19262 }
19263
19264 free_debug_memory ();
19265
19266 return res;
19267}
19268
19269/* Process an ELF archive.
19270 On entry the file is positioned just after the ARMAG string.
19271 Returns TRUE upon success, FALSE otherwise. */
19272
19273static bfd_boolean
19274process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19275{
19276 struct archive_info arch;
19277 struct archive_info nested_arch;
19278 size_t got;
19279 bfd_boolean ret = TRUE;
19280
19281 show_name = TRUE;
19282
19283 /* The ARCH structure is used to hold information about this archive. */
19284 arch.file_name = NULL;
19285 arch.file = NULL;
19286 arch.index_array = NULL;
19287 arch.sym_table = NULL;
19288 arch.longnames = NULL;
19289
19290 /* The NESTED_ARCH structure is used as a single-item cache of information
19291 about a nested archive (when members of a thin archive reside within
19292 another regular archive file). */
19293 nested_arch.file_name = NULL;
19294 nested_arch.file = NULL;
19295 nested_arch.index_array = NULL;
19296 nested_arch.sym_table = NULL;
19297 nested_arch.longnames = NULL;
19298
19299 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19300 is_thin_archive, do_archive_index) != 0)
19301 {
19302 ret = FALSE;
19303 goto out;
19304 }
19305
19306 if (do_archive_index)
19307 {
19308 if (arch.sym_table == NULL)
19309 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19310 else
19311 {
19312 unsigned long i, l;
19313 unsigned long current_pos;
19314
19315 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19316 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19317
19318 current_pos = ftell (filedata->handle);
19319
19320 for (i = l = 0; i < arch.index_num; i++)
19321 {
19322 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19323 {
19324 char * member_name;
19325
19326 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19327
19328 if (member_name != NULL)
19329 {
19330 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19331
19332 if (qualified_name != NULL)
19333 {
19334 printf (_("Contents of binary %s at offset "), qualified_name);
19335 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19336 putchar ('\n');
19337 free (qualified_name);
19338 }
19339 }
19340 }
19341
19342 if (l >= arch.sym_size)
19343 {
19344 error (_("%s: end of the symbol table reached before the end of the index\n"),
19345 filedata->file_name);
19346 ret = FALSE;
19347 break;
19348 }
19349 /* PR 17531: file: 0b6630b2. */
19350 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19351 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19352 }
19353
19354 if (arch.uses_64bit_indices)
19355 l = (l + 7) & ~ 7;
19356 else
19357 l += l & 1;
19358
19359 if (l < arch.sym_size)
19360 {
19361 error (ngettext ("%s: %ld byte remains in the symbol table, "
19362 "but without corresponding entries in "
19363 "the index table\n",
19364 "%s: %ld bytes remain in the symbol table, "
19365 "but without corresponding entries in "
19366 "the index table\n",
19367 arch.sym_size - l),
19368 filedata->file_name, arch.sym_size - l);
19369 ret = FALSE;
19370 }
19371
19372 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19373 {
19374 error (_("%s: failed to seek back to start of object files in the archive\n"),
19375 filedata->file_name);
19376 ret = FALSE;
19377 goto out;
19378 }
19379 }
19380
19381 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19382 && !do_segments && !do_header && !do_dump && !do_version
19383 && !do_histogram && !do_debugging && !do_arch && !do_notes
19384 && !do_section_groups && !do_dyn_syms)
19385 {
19386 ret = TRUE; /* Archive index only. */
19387 goto out;
19388 }
19389 }
19390
19391 while (1)
19392 {
19393 char * name;
19394 size_t namelen;
19395 char * qualified_name;
19396
19397 /* Read the next archive header. */
19398 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19399 {
19400 error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19401 return FALSE;
19402 }
19403 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19404 if (got != sizeof arch.arhdr)
19405 {
19406 if (got == 0)
19407 break;
19408 error (_("%s: failed to read archive header\n"), filedata->file_name);
19409 ret = FALSE;
19410 break;
19411 }
19412 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19413 {
19414 error (_("%s: did not find a valid archive header\n"), arch.file_name);
19415 ret = FALSE;
19416 break;
19417 }
19418
19419 arch.next_arhdr_offset += sizeof arch.arhdr;
19420
19421 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19422 if (archive_file_size & 01)
19423 ++archive_file_size;
19424
19425 name = get_archive_member_name (&arch, &nested_arch);
19426 if (name == NULL)
19427 {
19428 error (_("%s: bad archive file name\n"), filedata->file_name);
19429 ret = FALSE;
19430 break;
19431 }
19432 namelen = strlen (name);
19433
19434 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19435 if (qualified_name == NULL)
19436 {
19437 error (_("%s: bad archive file name\n"), filedata->file_name);
19438 ret = FALSE;
19439 break;
19440 }
19441
19442 if (is_thin_archive && arch.nested_member_origin == 0)
19443 {
19444 /* This is a proxy for an external member of a thin archive. */
19445 Filedata * member_filedata;
19446 char * member_file_name = adjust_relative_path
19447 (filedata->file_name, name, namelen);
19448
19449 if (member_file_name == NULL)
19450 {
19451 ret = FALSE;
19452 break;
19453 }
19454
19455 member_filedata = open_file (member_file_name);
19456 if (member_filedata == NULL)
19457 {
19458 error (_("Input file '%s' is not readable.\n"), member_file_name);
19459 free (member_file_name);
19460 ret = FALSE;
19461 break;
19462 }
19463
19464 archive_file_offset = arch.nested_member_origin;
19465 member_filedata->file_name = qualified_name;
19466
19467 if (! process_object (member_filedata))
19468 ret = FALSE;
19469
19470 close_file (member_filedata);
19471 free (member_file_name);
19472 }
19473 else if (is_thin_archive)
19474 {
19475 Filedata thin_filedata;
19476
19477 memset (&thin_filedata, 0, sizeof (thin_filedata));
19478
19479 /* PR 15140: Allow for corrupt thin archives. */
19480 if (nested_arch.file == NULL)
19481 {
19482 error (_("%s: contains corrupt thin archive: %s\n"),
19483 filedata->file_name, name);
19484 ret = FALSE;
19485 break;
19486 }
19487
19488 /* This is a proxy for a member of a nested archive. */
19489 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19490
19491 /* The nested archive file will have been opened and setup by
19492 get_archive_member_name. */
19493 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19494 {
19495 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19496 ret = FALSE;
19497 break;
19498 }
19499
19500 thin_filedata.handle = nested_arch.file;
19501 thin_filedata.file_name = qualified_name;
19502
19503 if (! process_object (& thin_filedata))
19504 ret = FALSE;
19505 }
19506 else
19507 {
19508 archive_file_offset = arch.next_arhdr_offset;
19509 arch.next_arhdr_offset += archive_file_size;
19510
19511 filedata->file_name = qualified_name;
19512 if (! process_object (filedata))
19513 ret = FALSE;
19514 }
19515
19516 if (filedata->dump_sects != NULL)
19517 {
19518 free (filedata->dump_sects);
19519 filedata->dump_sects = NULL;
19520 filedata->num_dump_sects = 0;
19521 }
19522
19523 free (qualified_name);
19524 }
19525
19526 out:
19527 if (nested_arch.file != NULL)
19528 fclose (nested_arch.file);
19529 release_archive (&nested_arch);
19530 release_archive (&arch);
19531
19532 return ret;
19533}
19534
19535static bfd_boolean
19536process_file (char * file_name)
19537{
19538 Filedata * filedata = NULL;
19539 struct stat statbuf;
19540 char armag[SARMAG];
19541 bfd_boolean ret = TRUE;
19542
19543 if (stat (file_name, &statbuf) < 0)
19544 {
19545 if (errno == ENOENT)
19546 error (_("'%s': No such file\n"), file_name);
19547 else
19548 error (_("Could not locate '%s'. System error message: %s\n"),
19549 file_name, strerror (errno));
19550 return FALSE;
19551 }
19552
19553 if (! S_ISREG (statbuf.st_mode))
19554 {
19555 error (_("'%s' is not an ordinary file\n"), file_name);
19556 return FALSE;
19557 }
19558
19559 filedata = calloc (1, sizeof * filedata);
19560 if (filedata == NULL)
19561 {
19562 error (_("Out of memory allocating file data structure\n"));
19563 return FALSE;
19564 }
19565
19566 filedata->file_name = file_name;
19567 filedata->handle = fopen (file_name, "rb");
19568 if (filedata->handle == NULL)
19569 {
19570 error (_("Input file '%s' is not readable.\n"), file_name);
19571 free (filedata);
19572 return FALSE;
19573 }
19574
19575 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19576 {
19577 error (_("%s: Failed to read file's magic number\n"), file_name);
19578 fclose (filedata->handle);
19579 free (filedata);
19580 return FALSE;
19581 }
19582
19583 filedata->file_size = (bfd_size_type) statbuf.st_size;
19584
19585 if (memcmp (armag, ARMAG, SARMAG) == 0)
19586 {
19587 if (! process_archive (filedata, FALSE))
19588 ret = FALSE;
19589 }
19590 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19591 {
19592 if ( ! process_archive (filedata, TRUE))
19593 ret = FALSE;
19594 }
19595 else
19596 {
19597 if (do_archive_index)
19598 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19599 file_name);
19600
19601 rewind (filedata->handle);
19602 archive_file_size = archive_file_offset = 0;
19603
19604 if (! process_object (filedata))
19605 ret = FALSE;
19606 }
19607
19608 fclose (filedata->handle);
19609 free (filedata);
19610
19611 return ret;
19612}
19613
19614#ifdef SUPPORT_DISASSEMBLY
19615/* Needed by the i386 disassembler. For extra credit, someone could
19616 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19617 symbols. */
19618
19619void
19620print_address (unsigned int addr, FILE * outfile)
19621{
19622 fprintf (outfile,"0x%8.8x", addr);
19623}
19624
19625/* Needed by the i386 disassembler. */
19626
19627void
19628db_task_printsym (unsigned int addr)
19629{
19630 print_address (addr, stderr);
19631}
19632#endif
19633
19634int
19635main (int argc, char ** argv)
19636{
19637 int err;
19638
19639#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19640 setlocale (LC_MESSAGES, "");
19641#endif
19642#if defined (HAVE_SETLOCALE)
19643 setlocale (LC_CTYPE, "");
19644#endif
19645 bindtextdomain (PACKAGE, LOCALEDIR);
19646 textdomain (PACKAGE);
19647
19648 expandargv (&argc, &argv);
19649
19650 cmdline.file_name = "<cmdline>";
19651 parse_args (& cmdline, argc, argv);
19652
19653 if (optind < (argc - 1))
19654 show_name = TRUE;
19655 else if (optind >= argc)
19656 {
19657 warn (_("Nothing to do.\n"));
19658 usage (stderr);
19659 }
19660
19661 err = FALSE;
19662 while (optind < argc)
19663 if (! process_file (argv[optind++]))
19664 err = TRUE;
19665
19666 if (cmdline.dump_sects != NULL)
19667 free (cmdline.dump_sects);
19668
19669 return err ? EXIT_FAILURE : EXIT_SUCCESS;
19670}
A mirror of the official binutils-gdb repository