]> 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
x86: Add GNU_PROPERTY_X86_UINT32_VALID
[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_LS3A: strcat (buf, ", loongson-3a"); break;
3408 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3409 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3410 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3411 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3412 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3413 case 0:
3414 /* We simply ignore the field in this case to avoid confusion:
3415 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3416 extension. */
3417 break;
3418 default: strcat (buf, _(", unknown CPU")); break;
3419 }
3420
3421 switch ((e_flags & EF_MIPS_ABI))
3422 {
3423 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3424 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3425 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3426 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3427 case 0:
3428 /* We simply ignore the field in this case to avoid confusion:
3429 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3430 This means it is likely to be an o32 file, but not for
3431 sure. */
3432 break;
3433 default: strcat (buf, _(", unknown ABI")); break;
3434 }
3435
3436 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3437 strcat (buf, ", mdmx");
3438
3439 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3440 strcat (buf, ", mips16");
3441
3442 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3443 strcat (buf, ", micromips");
3444
3445 switch ((e_flags & EF_MIPS_ARCH))
3446 {
3447 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3448 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3449 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3450 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3451 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3452 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3453 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3454 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3455 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3456 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3457 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3458 default: strcat (buf, _(", unknown ISA")); break;
3459 }
3460 break;
3461
3462 case EM_NDS32:
3463 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3464 break;
3465
3466 case EM_NFP:
3467 switch (EF_NFP_MACH (e_flags))
3468 {
3469 case E_NFP_MACH_3200:
3470 strcat (buf, ", NFP-32xx");
3471 break;
3472 case E_NFP_MACH_6000:
3473 strcat (buf, ", NFP-6xxx");
3474 break;
3475 }
3476 break;
3477
3478 case EM_RISCV:
3479 if (e_flags & EF_RISCV_RVC)
3480 strcat (buf, ", RVC");
3481
3482 if (e_flags & EF_RISCV_RVE)
3483 strcat (buf, ", RVE");
3484
3485 switch (e_flags & EF_RISCV_FLOAT_ABI)
3486 {
3487 case EF_RISCV_FLOAT_ABI_SOFT:
3488 strcat (buf, ", soft-float ABI");
3489 break;
3490
3491 case EF_RISCV_FLOAT_ABI_SINGLE:
3492 strcat (buf, ", single-float ABI");
3493 break;
3494
3495 case EF_RISCV_FLOAT_ABI_DOUBLE:
3496 strcat (buf, ", double-float ABI");
3497 break;
3498
3499 case EF_RISCV_FLOAT_ABI_QUAD:
3500 strcat (buf, ", quad-float ABI");
3501 break;
3502 }
3503 break;
3504
3505 case EM_SH:
3506 switch ((e_flags & EF_SH_MACH_MASK))
3507 {
3508 case EF_SH1: strcat (buf, ", sh1"); break;
3509 case EF_SH2: strcat (buf, ", sh2"); break;
3510 case EF_SH3: strcat (buf, ", sh3"); break;
3511 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3512 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3513 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3514 case EF_SH3E: strcat (buf, ", sh3e"); break;
3515 case EF_SH4: strcat (buf, ", sh4"); break;
3516 case EF_SH5: strcat (buf, ", sh5"); break;
3517 case EF_SH2E: strcat (buf, ", sh2e"); break;
3518 case EF_SH4A: strcat (buf, ", sh4a"); break;
3519 case EF_SH2A: strcat (buf, ", sh2a"); break;
3520 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3521 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3522 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3523 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3524 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3525 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3526 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3527 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3528 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3529 default: strcat (buf, _(", unknown ISA")); break;
3530 }
3531
3532 if (e_flags & EF_SH_PIC)
3533 strcat (buf, ", pic");
3534
3535 if (e_flags & EF_SH_FDPIC)
3536 strcat (buf, ", fdpic");
3537 break;
3538
3539 case EM_OR1K:
3540 if (e_flags & EF_OR1K_NODELAY)
3541 strcat (buf, ", no delay");
3542 break;
3543
3544 case EM_SPARCV9:
3545 if (e_flags & EF_SPARC_32PLUS)
3546 strcat (buf, ", v8+");
3547
3548 if (e_flags & EF_SPARC_SUN_US1)
3549 strcat (buf, ", ultrasparcI");
3550
3551 if (e_flags & EF_SPARC_SUN_US3)
3552 strcat (buf, ", ultrasparcIII");
3553
3554 if (e_flags & EF_SPARC_HAL_R1)
3555 strcat (buf, ", halr1");
3556
3557 if (e_flags & EF_SPARC_LEDATA)
3558 strcat (buf, ", ledata");
3559
3560 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3561 strcat (buf, ", tso");
3562
3563 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3564 strcat (buf, ", pso");
3565
3566 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3567 strcat (buf, ", rmo");
3568 break;
3569
3570 case EM_PARISC:
3571 switch (e_flags & EF_PARISC_ARCH)
3572 {
3573 case EFA_PARISC_1_0:
3574 strcpy (buf, ", PA-RISC 1.0");
3575 break;
3576 case EFA_PARISC_1_1:
3577 strcpy (buf, ", PA-RISC 1.1");
3578 break;
3579 case EFA_PARISC_2_0:
3580 strcpy (buf, ", PA-RISC 2.0");
3581 break;
3582 default:
3583 break;
3584 }
3585 if (e_flags & EF_PARISC_TRAPNIL)
3586 strcat (buf, ", trapnil");
3587 if (e_flags & EF_PARISC_EXT)
3588 strcat (buf, ", ext");
3589 if (e_flags & EF_PARISC_LSB)
3590 strcat (buf, ", lsb");
3591 if (e_flags & EF_PARISC_WIDE)
3592 strcat (buf, ", wide");
3593 if (e_flags & EF_PARISC_NO_KABP)
3594 strcat (buf, ", no kabp");
3595 if (e_flags & EF_PARISC_LAZYSWAP)
3596 strcat (buf, ", lazyswap");
3597 break;
3598
3599 case EM_PJ:
3600 case EM_PJ_OLD:
3601 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3602 strcat (buf, ", new calling convention");
3603
3604 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3605 strcat (buf, ", gnu calling convention");
3606 break;
3607
3608 case EM_IA_64:
3609 if ((e_flags & EF_IA_64_ABI64))
3610 strcat (buf, ", 64-bit");
3611 else
3612 strcat (buf, ", 32-bit");
3613 if ((e_flags & EF_IA_64_REDUCEDFP))
3614 strcat (buf, ", reduced fp model");
3615 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3616 strcat (buf, ", no function descriptors, constant gp");
3617 else if ((e_flags & EF_IA_64_CONS_GP))
3618 strcat (buf, ", constant gp");
3619 if ((e_flags & EF_IA_64_ABSOLUTE))
3620 strcat (buf, ", absolute");
3621 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3622 {
3623 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3624 strcat (buf, ", vms_linkages");
3625 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3626 {
3627 case EF_IA_64_VMS_COMCOD_SUCCESS:
3628 break;
3629 case EF_IA_64_VMS_COMCOD_WARNING:
3630 strcat (buf, ", warning");
3631 break;
3632 case EF_IA_64_VMS_COMCOD_ERROR:
3633 strcat (buf, ", error");
3634 break;
3635 case EF_IA_64_VMS_COMCOD_ABORT:
3636 strcat (buf, ", abort");
3637 break;
3638 default:
3639 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3640 e_flags & EF_IA_64_VMS_COMCOD);
3641 strcat (buf, ", <unknown>");
3642 }
3643 }
3644 break;
3645
3646 case EM_VAX:
3647 if ((e_flags & EF_VAX_NONPIC))
3648 strcat (buf, ", non-PIC");
3649 if ((e_flags & EF_VAX_DFLOAT))
3650 strcat (buf, ", D-Float");
3651 if ((e_flags & EF_VAX_GFLOAT))
3652 strcat (buf, ", G-Float");
3653 break;
3654
3655 case EM_VISIUM:
3656 if (e_flags & EF_VISIUM_ARCH_MCM)
3657 strcat (buf, ", mcm");
3658 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3659 strcat (buf, ", mcm24");
3660 if (e_flags & EF_VISIUM_ARCH_GR6)
3661 strcat (buf, ", gr6");
3662 break;
3663
3664 case EM_RL78:
3665 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3666 {
3667 case E_FLAG_RL78_ANY_CPU: break;
3668 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3669 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3670 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3671 }
3672 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3673 strcat (buf, ", 64-bit doubles");
3674 break;
3675
3676 case EM_RX:
3677 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3678 strcat (buf, ", 64-bit doubles");
3679 if (e_flags & E_FLAG_RX_DSP)
3680 strcat (buf, ", dsp");
3681 if (e_flags & E_FLAG_RX_PID)
3682 strcat (buf, ", pid");
3683 if (e_flags & E_FLAG_RX_ABI)
3684 strcat (buf, ", RX ABI");
3685 if (e_flags & E_FLAG_RX_SINSNS_SET)
3686 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3687 ? ", uses String instructions" : ", bans String instructions");
3688 if (e_flags & E_FLAG_RX_V2)
3689 strcat (buf, ", V2");
3690 break;
3691
3692 case EM_S390:
3693 if (e_flags & EF_S390_HIGH_GPRS)
3694 strcat (buf, ", highgprs");
3695 break;
3696
3697 case EM_TI_C6000:
3698 if ((e_flags & EF_C6000_REL))
3699 strcat (buf, ", relocatable module");
3700 break;
3701
3702 case EM_MSP430:
3703 strcat (buf, _(": architecture variant: "));
3704 switch (e_flags & EF_MSP430_MACH)
3705 {
3706 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3707 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3708 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3709 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3710 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3711 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3712 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3713 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3714 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3715 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3716 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3717 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3718 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3719 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3720 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3721 default:
3722 strcat (buf, _(": unknown")); break;
3723 }
3724
3725 if (e_flags & ~ EF_MSP430_MACH)
3726 strcat (buf, _(": unknown extra flag bits also present"));
3727 }
3728 }
3729
3730 return buf;
3731}
3732
3733static const char *
3734get_osabi_name (Filedata * filedata, unsigned int osabi)
3735{
3736 static char buff[32];
3737
3738 switch (osabi)
3739 {
3740 case ELFOSABI_NONE: return "UNIX - System V";
3741 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3742 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3743 case ELFOSABI_GNU: return "UNIX - GNU";
3744 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3745 case ELFOSABI_AIX: return "UNIX - AIX";
3746 case ELFOSABI_IRIX: return "UNIX - IRIX";
3747 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3748 case ELFOSABI_TRU64: return "UNIX - TRU64";
3749 case ELFOSABI_MODESTO: return "Novell - Modesto";
3750 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3751 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3752 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3753 case ELFOSABI_AROS: return "AROS";
3754 case ELFOSABI_FENIXOS: return "FenixOS";
3755 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3756 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3757 default:
3758 if (osabi >= 64)
3759 switch (filedata->file_header.e_machine)
3760 {
3761 case EM_ARM:
3762 switch (osabi)
3763 {
3764 case ELFOSABI_ARM: return "ARM";
3765 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3766 default:
3767 break;
3768 }
3769 break;
3770
3771 case EM_MSP430:
3772 case EM_MSP430_OLD:
3773 case EM_VISIUM:
3774 switch (osabi)
3775 {
3776 case ELFOSABI_STANDALONE: return _("Standalone App");
3777 default:
3778 break;
3779 }
3780 break;
3781
3782 case EM_TI_C6000:
3783 switch (osabi)
3784 {
3785 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3786 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3787 default:
3788 break;
3789 }
3790 break;
3791
3792 default:
3793 break;
3794 }
3795 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3796 return buff;
3797 }
3798}
3799
3800static const char *
3801get_aarch64_segment_type (unsigned long type)
3802{
3803 switch (type)
3804 {
3805 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3806 default: return NULL;
3807 }
3808}
3809
3810static const char *
3811get_arm_segment_type (unsigned long type)
3812{
3813 switch (type)
3814 {
3815 case PT_ARM_EXIDX: return "EXIDX";
3816 default: return NULL;
3817 }
3818}
3819
3820static const char *
3821get_s390_segment_type (unsigned long type)
3822{
3823 switch (type)
3824 {
3825 case PT_S390_PGSTE: return "S390_PGSTE";
3826 default: return NULL;
3827 }
3828}
3829
3830static const char *
3831get_mips_segment_type (unsigned long type)
3832{
3833 switch (type)
3834 {
3835 case PT_MIPS_REGINFO: return "REGINFO";
3836 case PT_MIPS_RTPROC: return "RTPROC";
3837 case PT_MIPS_OPTIONS: return "OPTIONS";
3838 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3839 default: return NULL;
3840 }
3841}
3842
3843static const char *
3844get_parisc_segment_type (unsigned long type)
3845{
3846 switch (type)
3847 {
3848 case PT_HP_TLS: return "HP_TLS";
3849 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3850 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3851 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3852 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3853 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3854 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3855 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3856 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3857 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3858 case PT_HP_PARALLEL: return "HP_PARALLEL";
3859 case PT_HP_FASTBIND: return "HP_FASTBIND";
3860 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3861 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3862 case PT_HP_STACK: return "HP_STACK";
3863 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3864 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3865 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3866 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3867 default: return NULL;
3868 }
3869}
3870
3871static const char *
3872get_ia64_segment_type (unsigned long type)
3873{
3874 switch (type)
3875 {
3876 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3877 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3878 case PT_HP_TLS: return "HP_TLS";
3879 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3880 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3881 case PT_IA_64_HP_STACK: return "HP_STACK";
3882 default: return NULL;
3883 }
3884}
3885
3886static const char *
3887get_tic6x_segment_type (unsigned long type)
3888{
3889 switch (type)
3890 {
3891 case PT_C6000_PHATTR: return "C6000_PHATTR";
3892 default: return NULL;
3893 }
3894}
3895
3896static const char *
3897get_solaris_segment_type (unsigned long type)
3898{
3899 switch (type)
3900 {
3901 case 0x6464e550: return "PT_SUNW_UNWIND";
3902 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3903 case 0x6ffffff7: return "PT_LOSUNW";
3904 case 0x6ffffffa: return "PT_SUNWBSS";
3905 case 0x6ffffffb: return "PT_SUNWSTACK";
3906 case 0x6ffffffc: return "PT_SUNWDTRACE";
3907 case 0x6ffffffd: return "PT_SUNWCAP";
3908 case 0x6fffffff: return "PT_HISUNW";
3909 default: return NULL;
3910 }
3911}
3912
3913static const char *
3914get_segment_type (Filedata * filedata, unsigned long p_type)
3915{
3916 static char buff[32];
3917
3918 switch (p_type)
3919 {
3920 case PT_NULL: return "NULL";
3921 case PT_LOAD: return "LOAD";
3922 case PT_DYNAMIC: return "DYNAMIC";
3923 case PT_INTERP: return "INTERP";
3924 case PT_NOTE: return "NOTE";
3925 case PT_SHLIB: return "SHLIB";
3926 case PT_PHDR: return "PHDR";
3927 case PT_TLS: return "TLS";
3928 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3929 case PT_GNU_STACK: return "GNU_STACK";
3930 case PT_GNU_RELRO: return "GNU_RELRO";
3931
3932 default:
3933 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3934 {
3935 sprintf (buff, "GNU_MBIND+%#lx",
3936 p_type - PT_GNU_MBIND_LO);
3937 }
3938 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3939 {
3940 const char * result;
3941
3942 switch (filedata->file_header.e_machine)
3943 {
3944 case EM_AARCH64:
3945 result = get_aarch64_segment_type (p_type);
3946 break;
3947 case EM_ARM:
3948 result = get_arm_segment_type (p_type);
3949 break;
3950 case EM_MIPS:
3951 case EM_MIPS_RS3_LE:
3952 result = get_mips_segment_type (p_type);
3953 break;
3954 case EM_PARISC:
3955 result = get_parisc_segment_type (p_type);
3956 break;
3957 case EM_IA_64:
3958 result = get_ia64_segment_type (p_type);
3959 break;
3960 case EM_TI_C6000:
3961 result = get_tic6x_segment_type (p_type);
3962 break;
3963 case EM_S390:
3964 case EM_S390_OLD:
3965 result = get_s390_segment_type (p_type);
3966 break;
3967 default:
3968 result = NULL;
3969 break;
3970 }
3971
3972 if (result != NULL)
3973 return result;
3974
3975 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3976 }
3977 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3978 {
3979 const char * result;
3980
3981 switch (filedata->file_header.e_machine)
3982 {
3983 case EM_PARISC:
3984 result = get_parisc_segment_type (p_type);
3985 break;
3986 case EM_IA_64:
3987 result = get_ia64_segment_type (p_type);
3988 break;
3989 default:
3990 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3991 result = get_solaris_segment_type (p_type);
3992 else
3993 result = NULL;
3994 break;
3995 }
3996
3997 if (result != NULL)
3998 return result;
3999
4000 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4001 }
4002 else
4003 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4004
4005 return buff;
4006 }
4007}
4008
4009static const char *
4010get_arc_section_type_name (unsigned int sh_type)
4011{
4012 switch (sh_type)
4013 {
4014 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4015 default:
4016 break;
4017 }
4018 return NULL;
4019}
4020
4021static const char *
4022get_mips_section_type_name (unsigned int sh_type)
4023{
4024 switch (sh_type)
4025 {
4026 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4027 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4028 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4029 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4030 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4031 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4032 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4033 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4034 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4035 case SHT_MIPS_RELD: return "MIPS_RELD";
4036 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4037 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4038 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4039 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4040 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4041 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4042 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4043 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4044 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4045 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4046 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4047 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4048 case SHT_MIPS_LINE: return "MIPS_LINE";
4049 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4050 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4051 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4052 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4053 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4054 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4055 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4056 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4057 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4058 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4059 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4060 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4061 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4062 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4063 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4064 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4065 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4066 default:
4067 break;
4068 }
4069 return NULL;
4070}
4071
4072static const char *
4073get_parisc_section_type_name (unsigned int sh_type)
4074{
4075 switch (sh_type)
4076 {
4077 case SHT_PARISC_EXT: return "PARISC_EXT";
4078 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4079 case SHT_PARISC_DOC: return "PARISC_DOC";
4080 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4081 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4082 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4083 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4084 default: return NULL;
4085 }
4086}
4087
4088static const char *
4089get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4090{
4091 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4092 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4093 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4094
4095 switch (sh_type)
4096 {
4097 case SHT_IA_64_EXT: return "IA_64_EXT";
4098 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4099 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4100 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4101 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4102 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4103 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4104 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4105 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4106 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4107 default:
4108 break;
4109 }
4110 return NULL;
4111}
4112
4113static const char *
4114get_x86_64_section_type_name (unsigned int sh_type)
4115{
4116 switch (sh_type)
4117 {
4118 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4119 default: return NULL;
4120 }
4121}
4122
4123static const char *
4124get_aarch64_section_type_name (unsigned int sh_type)
4125{
4126 switch (sh_type)
4127 {
4128 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4129 default: return NULL;
4130 }
4131}
4132
4133static const char *
4134get_arm_section_type_name (unsigned int sh_type)
4135{
4136 switch (sh_type)
4137 {
4138 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4139 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4140 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4141 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4142 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4143 default: return NULL;
4144 }
4145}
4146
4147static const char *
4148get_tic6x_section_type_name (unsigned int sh_type)
4149{
4150 switch (sh_type)
4151 {
4152 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4153 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4154 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4155 case SHT_TI_ICODE: return "TI_ICODE";
4156 case SHT_TI_XREF: return "TI_XREF";
4157 case SHT_TI_HANDLER: return "TI_HANDLER";
4158 case SHT_TI_INITINFO: return "TI_INITINFO";
4159 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4160 default: return NULL;
4161 }
4162}
4163
4164static const char *
4165get_msp430x_section_type_name (unsigned int sh_type)
4166{
4167 switch (sh_type)
4168 {
4169 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4170 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4171 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4172 default: return NULL;
4173 }
4174}
4175
4176static const char *
4177get_nfp_section_type_name (unsigned int sh_type)
4178{
4179 switch (sh_type)
4180 {
4181 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4182 case SHT_NFP_INITREG: return "NFP_INITREG";
4183 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4184 default: return NULL;
4185 }
4186}
4187
4188static const char *
4189get_v850_section_type_name (unsigned int sh_type)
4190{
4191 switch (sh_type)
4192 {
4193 case SHT_V850_SCOMMON: return "V850 Small Common";
4194 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4195 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4196 case SHT_RENESAS_IOP: return "RENESAS IOP";
4197 case SHT_RENESAS_INFO: return "RENESAS INFO";
4198 default: return NULL;
4199 }
4200}
4201
4202static const char *
4203get_section_type_name (Filedata * filedata, unsigned int sh_type)
4204{
4205 static char buff[32];
4206 const char * result;
4207
4208 switch (sh_type)
4209 {
4210 case SHT_NULL: return "NULL";
4211 case SHT_PROGBITS: return "PROGBITS";
4212 case SHT_SYMTAB: return "SYMTAB";
4213 case SHT_STRTAB: return "STRTAB";
4214 case SHT_RELA: return "RELA";
4215 case SHT_HASH: return "HASH";
4216 case SHT_DYNAMIC: return "DYNAMIC";
4217 case SHT_NOTE: return "NOTE";
4218 case SHT_NOBITS: return "NOBITS";
4219 case SHT_REL: return "REL";
4220 case SHT_SHLIB: return "SHLIB";
4221 case SHT_DYNSYM: return "DYNSYM";
4222 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4223 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4224 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4225 case SHT_GNU_HASH: return "GNU_HASH";
4226 case SHT_GROUP: return "GROUP";
4227 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4228 case SHT_GNU_verdef: return "VERDEF";
4229 case SHT_GNU_verneed: return "VERNEED";
4230 case SHT_GNU_versym: return "VERSYM";
4231 case 0x6ffffff0: return "VERSYM";
4232 case 0x6ffffffc: return "VERDEF";
4233 case 0x7ffffffd: return "AUXILIARY";
4234 case 0x7fffffff: return "FILTER";
4235 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4236
4237 default:
4238 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4239 {
4240 switch (filedata->file_header.e_machine)
4241 {
4242 case EM_ARC:
4243 case EM_ARC_COMPACT:
4244 case EM_ARC_COMPACT2:
4245 result = get_arc_section_type_name (sh_type);
4246 break;
4247 case EM_MIPS:
4248 case EM_MIPS_RS3_LE:
4249 result = get_mips_section_type_name (sh_type);
4250 break;
4251 case EM_PARISC:
4252 result = get_parisc_section_type_name (sh_type);
4253 break;
4254 case EM_IA_64:
4255 result = get_ia64_section_type_name (filedata, sh_type);
4256 break;
4257 case EM_X86_64:
4258 case EM_L1OM:
4259 case EM_K1OM:
4260 result = get_x86_64_section_type_name (sh_type);
4261 break;
4262 case EM_AARCH64:
4263 result = get_aarch64_section_type_name (sh_type);
4264 break;
4265 case EM_ARM:
4266 result = get_arm_section_type_name (sh_type);
4267 break;
4268 case EM_TI_C6000:
4269 result = get_tic6x_section_type_name (sh_type);
4270 break;
4271 case EM_MSP430:
4272 result = get_msp430x_section_type_name (sh_type);
4273 break;
4274 case EM_NFP:
4275 result = get_nfp_section_type_name (sh_type);
4276 break;
4277 case EM_V800:
4278 case EM_V850:
4279 case EM_CYGNUS_V850:
4280 result = get_v850_section_type_name (sh_type);
4281 break;
4282 default:
4283 result = NULL;
4284 break;
4285 }
4286
4287 if (result != NULL)
4288 return result;
4289
4290 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4291 }
4292 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4293 {
4294 switch (filedata->file_header.e_machine)
4295 {
4296 case EM_IA_64:
4297 result = get_ia64_section_type_name (filedata, sh_type);
4298 break;
4299 default:
4300 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4301 result = get_solaris_section_type (sh_type);
4302 else
4303 {
4304 switch (sh_type)
4305 {
4306 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4307 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4308 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4309 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4310 default:
4311 result = NULL;
4312 break;
4313 }
4314 }
4315 break;
4316 }
4317
4318 if (result != NULL)
4319 return result;
4320
4321 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4322 }
4323 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4324 {
4325 switch (filedata->file_header.e_machine)
4326 {
4327 case EM_V800:
4328 case EM_V850:
4329 case EM_CYGNUS_V850:
4330 result = get_v850_section_type_name (sh_type);
4331 break;
4332 default:
4333 result = NULL;
4334 break;
4335 }
4336
4337 if (result != NULL)
4338 return result;
4339
4340 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4341 }
4342 else
4343 /* This message is probably going to be displayed in a 15
4344 character wide field, so put the hex value first. */
4345 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4346
4347 return buff;
4348 }
4349}
4350
4351#define OPTION_DEBUG_DUMP 512
4352#define OPTION_DYN_SYMS 513
4353#define OPTION_DWARF_DEPTH 514
4354#define OPTION_DWARF_START 515
4355#define OPTION_DWARF_CHECK 516
4356
4357static struct option options[] =
4358{
4359 {"all", no_argument, 0, 'a'},
4360 {"file-header", no_argument, 0, 'h'},
4361 {"program-headers", no_argument, 0, 'l'},
4362 {"headers", no_argument, 0, 'e'},
4363 {"histogram", no_argument, 0, 'I'},
4364 {"segments", no_argument, 0, 'l'},
4365 {"sections", no_argument, 0, 'S'},
4366 {"section-headers", no_argument, 0, 'S'},
4367 {"section-groups", no_argument, 0, 'g'},
4368 {"section-details", no_argument, 0, 't'},
4369 {"full-section-name",no_argument, 0, 'N'},
4370 {"symbols", no_argument, 0, 's'},
4371 {"syms", no_argument, 0, 's'},
4372 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4373 {"relocs", no_argument, 0, 'r'},
4374 {"notes", no_argument, 0, 'n'},
4375 {"dynamic", no_argument, 0, 'd'},
4376 {"arch-specific", no_argument, 0, 'A'},
4377 {"version-info", no_argument, 0, 'V'},
4378 {"use-dynamic", no_argument, 0, 'D'},
4379 {"unwind", no_argument, 0, 'u'},
4380 {"archive-index", no_argument, 0, 'c'},
4381 {"hex-dump", required_argument, 0, 'x'},
4382 {"relocated-dump", required_argument, 0, 'R'},
4383 {"string-dump", required_argument, 0, 'p'},
4384 {"decompress", no_argument, 0, 'z'},
4385#ifdef SUPPORT_DISASSEMBLY
4386 {"instruction-dump", required_argument, 0, 'i'},
4387#endif
4388 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4389
4390 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4391 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4392 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4393
4394 {"version", no_argument, 0, 'v'},
4395 {"wide", no_argument, 0, 'W'},
4396 {"help", no_argument, 0, 'H'},
4397 {0, no_argument, 0, 0}
4398};
4399
4400static void
4401usage (FILE * stream)
4402{
4403 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4404 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4405 fprintf (stream, _(" Options are:\n\
4406 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4407 -h --file-header Display the ELF file header\n\
4408 -l --program-headers Display the program headers\n\
4409 --segments An alias for --program-headers\n\
4410 -S --section-headers Display the sections' header\n\
4411 --sections An alias for --section-headers\n\
4412 -g --section-groups Display the section groups\n\
4413 -t --section-details Display the section details\n\
4414 -e --headers Equivalent to: -h -l -S\n\
4415 -s --syms Display the symbol table\n\
4416 --symbols An alias for --syms\n\
4417 --dyn-syms Display the dynamic symbol table\n\
4418 -n --notes Display the core notes (if present)\n\
4419 -r --relocs Display the relocations (if present)\n\
4420 -u --unwind Display the unwind info (if present)\n\
4421 -d --dynamic Display the dynamic section (if present)\n\
4422 -V --version-info Display the version sections (if present)\n\
4423 -A --arch-specific Display architecture specific information (if any)\n\
4424 -c --archive-index Display the symbol/file index in an archive\n\
4425 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4426 -x --hex-dump=<number|name>\n\
4427 Dump the contents of section <number|name> as bytes\n\
4428 -p --string-dump=<number|name>\n\
4429 Dump the contents of section <number|name> as strings\n\
4430 -R --relocated-dump=<number|name>\n\
4431 Dump the contents of section <number|name> as relocated bytes\n\
4432 -z --decompress Decompress section before dumping it\n\
4433 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4434 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4435 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4436 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4437 =addr,=cu_index,=links,=follow-links]\n\
4438 Display the contents of DWARF debug sections\n"));
4439 fprintf (stream, _("\
4440 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4441 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4442 or deeper\n"));
4443#ifdef SUPPORT_DISASSEMBLY
4444 fprintf (stream, _("\
4445 -i --instruction-dump=<number|name>\n\
4446 Disassemble the contents of section <number|name>\n"));
4447#endif
4448 fprintf (stream, _("\
4449 -I --histogram Display histogram of bucket list lengths\n\
4450 -W --wide Allow output width to exceed 80 characters\n\
4451 @<file> Read options from <file>\n\
4452 -H --help Display this information\n\
4453 -v --version Display the version number of readelf\n"));
4454
4455 if (REPORT_BUGS_TO[0] && stream == stdout)
4456 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4457
4458 exit (stream == stdout ? 0 : 1);
4459}
4460
4461/* Record the fact that the user wants the contents of section number
4462 SECTION to be displayed using the method(s) encoded as flags bits
4463 in TYPE. Note, TYPE can be zero if we are creating the array for
4464 the first time. */
4465
4466static void
4467request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4468{
4469 if (section >= filedata->num_dump_sects)
4470 {
4471 dump_type * new_dump_sects;
4472
4473 new_dump_sects = (dump_type *) calloc (section + 1,
4474 sizeof (* new_dump_sects));
4475
4476 if (new_dump_sects == NULL)
4477 error (_("Out of memory allocating dump request table.\n"));
4478 else
4479 {
4480 if (filedata->dump_sects)
4481 {
4482 /* Copy current flag settings. */
4483 memcpy (new_dump_sects, filedata->dump_sects,
4484 filedata->num_dump_sects * sizeof (* new_dump_sects));
4485
4486 free (filedata->dump_sects);
4487 }
4488
4489 filedata->dump_sects = new_dump_sects;
4490 filedata->num_dump_sects = section + 1;
4491 }
4492 }
4493
4494 if (filedata->dump_sects)
4495 filedata->dump_sects[section] |= type;
4496}
4497
4498/* Request a dump by section name. */
4499
4500static void
4501request_dump_byname (const char * section, dump_type type)
4502{
4503 struct dump_list_entry * new_request;
4504
4505 new_request = (struct dump_list_entry *)
4506 malloc (sizeof (struct dump_list_entry));
4507 if (!new_request)
4508 error (_("Out of memory allocating dump request table.\n"));
4509
4510 new_request->name = strdup (section);
4511 if (!new_request->name)
4512 error (_("Out of memory allocating dump request table.\n"));
4513
4514 new_request->type = type;
4515
4516 new_request->next = dump_sects_byname;
4517 dump_sects_byname = new_request;
4518}
4519
4520static inline void
4521request_dump (Filedata * filedata, dump_type type)
4522{
4523 int section;
4524 char * cp;
4525
4526 do_dump++;
4527 section = strtoul (optarg, & cp, 0);
4528
4529 if (! *cp && section >= 0)
4530 request_dump_bynumber (filedata, section, type);
4531 else
4532 request_dump_byname (optarg, type);
4533}
4534
4535static void
4536parse_args (Filedata * filedata, int argc, char ** argv)
4537{
4538 int c;
4539
4540 if (argc < 2)
4541 usage (stderr);
4542
4543 while ((c = getopt_long
4544 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4545 {
4546 switch (c)
4547 {
4548 case 0:
4549 /* Long options. */
4550 break;
4551 case 'H':
4552 usage (stdout);
4553 break;
4554
4555 case 'a':
4556 do_syms = TRUE;
4557 do_reloc = TRUE;
4558 do_unwind = TRUE;
4559 do_dynamic = TRUE;
4560 do_header = TRUE;
4561 do_sections = TRUE;
4562 do_section_groups = TRUE;
4563 do_segments = TRUE;
4564 do_version = TRUE;
4565 do_histogram = TRUE;
4566 do_arch = TRUE;
4567 do_notes = TRUE;
4568 break;
4569 case 'g':
4570 do_section_groups = TRUE;
4571 break;
4572 case 't':
4573 case 'N':
4574 do_sections = TRUE;
4575 do_section_details = TRUE;
4576 break;
4577 case 'e':
4578 do_header = TRUE;
4579 do_sections = TRUE;
4580 do_segments = TRUE;
4581 break;
4582 case 'A':
4583 do_arch = TRUE;
4584 break;
4585 case 'D':
4586 do_using_dynamic = TRUE;
4587 break;
4588 case 'r':
4589 do_reloc = TRUE;
4590 break;
4591 case 'u':
4592 do_unwind = TRUE;
4593 break;
4594 case 'h':
4595 do_header = TRUE;
4596 break;
4597 case 'l':
4598 do_segments = TRUE;
4599 break;
4600 case 's':
4601 do_syms = TRUE;
4602 break;
4603 case 'S':
4604 do_sections = TRUE;
4605 break;
4606 case 'd':
4607 do_dynamic = TRUE;
4608 break;
4609 case 'I':
4610 do_histogram = TRUE;
4611 break;
4612 case 'n':
4613 do_notes = TRUE;
4614 break;
4615 case 'c':
4616 do_archive_index = TRUE;
4617 break;
4618 case 'x':
4619 request_dump (filedata, HEX_DUMP);
4620 break;
4621 case 'p':
4622 request_dump (filedata, STRING_DUMP);
4623 break;
4624 case 'R':
4625 request_dump (filedata, RELOC_DUMP);
4626 break;
4627 case 'z':
4628 decompress_dumps = TRUE;
4629 break;
4630 case 'w':
4631 do_dump = TRUE;
4632 if (optarg == 0)
4633 {
4634 do_debugging = TRUE;
4635 dwarf_select_sections_all ();
4636 }
4637 else
4638 {
4639 do_debugging = FALSE;
4640 dwarf_select_sections_by_letters (optarg);
4641 }
4642 break;
4643 case OPTION_DEBUG_DUMP:
4644 do_dump = TRUE;
4645 if (optarg == 0)
4646 do_debugging = TRUE;
4647 else
4648 {
4649 do_debugging = FALSE;
4650 dwarf_select_sections_by_names (optarg);
4651 }
4652 break;
4653 case OPTION_DWARF_DEPTH:
4654 {
4655 char *cp;
4656
4657 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4658 }
4659 break;
4660 case OPTION_DWARF_START:
4661 {
4662 char *cp;
4663
4664 dwarf_start_die = strtoul (optarg, & cp, 0);
4665 }
4666 break;
4667 case OPTION_DWARF_CHECK:
4668 dwarf_check = TRUE;
4669 break;
4670 case OPTION_DYN_SYMS:
4671 do_dyn_syms = TRUE;
4672 break;
4673#ifdef SUPPORT_DISASSEMBLY
4674 case 'i':
4675 request_dump (filedata, DISASS_DUMP);
4676 break;
4677#endif
4678 case 'v':
4679 print_version (program_name);
4680 break;
4681 case 'V':
4682 do_version = TRUE;
4683 break;
4684 case 'W':
4685 do_wide = TRUE;
4686 break;
4687 default:
4688 /* xgettext:c-format */
4689 error (_("Invalid option '-%c'\n"), c);
4690 /* Fall through. */
4691 case '?':
4692 usage (stderr);
4693 }
4694 }
4695
4696 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4697 && !do_segments && !do_header && !do_dump && !do_version
4698 && !do_histogram && !do_debugging && !do_arch && !do_notes
4699 && !do_section_groups && !do_archive_index
4700 && !do_dyn_syms)
4701 usage (stderr);
4702}
4703
4704static const char *
4705get_elf_class (unsigned int elf_class)
4706{
4707 static char buff[32];
4708
4709 switch (elf_class)
4710 {
4711 case ELFCLASSNONE: return _("none");
4712 case ELFCLASS32: return "ELF32";
4713 case ELFCLASS64: return "ELF64";
4714 default:
4715 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4716 return buff;
4717 }
4718}
4719
4720static const char *
4721get_data_encoding (unsigned int encoding)
4722{
4723 static char buff[32];
4724
4725 switch (encoding)
4726 {
4727 case ELFDATANONE: return _("none");
4728 case ELFDATA2LSB: return _("2's complement, little endian");
4729 case ELFDATA2MSB: return _("2's complement, big endian");
4730 default:
4731 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4732 return buff;
4733 }
4734}
4735
4736/* Decode the data held in 'filedata->file_header'. */
4737
4738static bfd_boolean
4739process_file_header (Filedata * filedata)
4740{
4741 Elf_Internal_Ehdr * header = & filedata->file_header;
4742
4743 if ( header->e_ident[EI_MAG0] != ELFMAG0
4744 || header->e_ident[EI_MAG1] != ELFMAG1
4745 || header->e_ident[EI_MAG2] != ELFMAG2
4746 || header->e_ident[EI_MAG3] != ELFMAG3)
4747 {
4748 error
4749 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4750 return FALSE;
4751 }
4752
4753 init_dwarf_regnames (header->e_machine);
4754
4755 if (do_header)
4756 {
4757 unsigned i;
4758
4759 printf (_("ELF Header:\n"));
4760 printf (_(" Magic: "));
4761 for (i = 0; i < EI_NIDENT; i++)
4762 printf ("%2.2x ", header->e_ident[i]);
4763 printf ("\n");
4764 printf (_(" Class: %s\n"),
4765 get_elf_class (header->e_ident[EI_CLASS]));
4766 printf (_(" Data: %s\n"),
4767 get_data_encoding (header->e_ident[EI_DATA]));
4768 printf (_(" Version: %d%s\n"),
4769 header->e_ident[EI_VERSION],
4770 (header->e_ident[EI_VERSION] == EV_CURRENT
4771 ? _(" (current)")
4772 : (header->e_ident[EI_VERSION] != EV_NONE
4773 ? _(" <unknown>")
4774 : "")));
4775 printf (_(" OS/ABI: %s\n"),
4776 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4777 printf (_(" ABI Version: %d\n"),
4778 header->e_ident[EI_ABIVERSION]);
4779 printf (_(" Type: %s\n"),
4780 get_file_type (header->e_type));
4781 printf (_(" Machine: %s\n"),
4782 get_machine_name (header->e_machine));
4783 printf (_(" Version: 0x%lx\n"),
4784 header->e_version);
4785
4786 printf (_(" Entry point address: "));
4787 print_vma (header->e_entry, PREFIX_HEX);
4788 printf (_("\n Start of program headers: "));
4789 print_vma (header->e_phoff, DEC);
4790 printf (_(" (bytes into file)\n Start of section headers: "));
4791 print_vma (header->e_shoff, DEC);
4792 printf (_(" (bytes into file)\n"));
4793
4794 printf (_(" Flags: 0x%lx%s\n"),
4795 header->e_flags,
4796 get_machine_flags (filedata, header->e_flags, header->e_machine));
4797 printf (_(" Size of this header: %u (bytes)\n"),
4798 header->e_ehsize);
4799 printf (_(" Size of program headers: %u (bytes)\n"),
4800 header->e_phentsize);
4801 printf (_(" Number of program headers: %u"),
4802 header->e_phnum);
4803 if (filedata->section_headers != NULL
4804 && header->e_phnum == PN_XNUM
4805 && filedata->section_headers[0].sh_info != 0)
4806 {
4807 header->e_phnum = filedata->section_headers[0].sh_info;
4808 printf (" (%u)", header->e_phnum);
4809 }
4810 putc ('\n', stdout);
4811 printf (_(" Size of section headers: %u (bytes)\n"),
4812 header->e_shentsize);
4813 printf (_(" Number of section headers: %u"),
4814 header->e_shnum);
4815 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4816 {
4817 header->e_shnum = filedata->section_headers[0].sh_size;
4818 printf (" (%u)", header->e_shnum);
4819 }
4820 putc ('\n', stdout);
4821 printf (_(" Section header string table index: %u"),
4822 header->e_shstrndx);
4823 if (filedata->section_headers != NULL
4824 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4825 {
4826 header->e_shstrndx = filedata->section_headers[0].sh_link;
4827 printf (" (%u)", header->e_shstrndx);
4828 }
4829 if (header->e_shstrndx != SHN_UNDEF
4830 && header->e_shstrndx >= header->e_shnum)
4831 {
4832 header->e_shstrndx = SHN_UNDEF;
4833 printf (_(" <corrupt: out of range>"));
4834 }
4835 putc ('\n', stdout);
4836 }
4837
4838 if (filedata->section_headers != NULL)
4839 {
4840 if (header->e_phnum == PN_XNUM
4841 && filedata->section_headers[0].sh_info != 0)
4842 header->e_phnum = filedata->section_headers[0].sh_info;
4843 if (header->e_shnum == SHN_UNDEF)
4844 header->e_shnum = filedata->section_headers[0].sh_size;
4845 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4846 header->e_shstrndx = filedata->section_headers[0].sh_link;
4847 if (header->e_shstrndx >= header->e_shnum)
4848 header->e_shstrndx = SHN_UNDEF;
4849 free (filedata->section_headers);
4850 filedata->section_headers = NULL;
4851 }
4852
4853 return TRUE;
4854}
4855
4856/* Read in the program headers from FILEDATA and store them in PHEADERS.
4857 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4858
4859static bfd_boolean
4860get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4861{
4862 Elf32_External_Phdr * phdrs;
4863 Elf32_External_Phdr * external;
4864 Elf_Internal_Phdr * internal;
4865 unsigned int i;
4866 unsigned int size = filedata->file_header.e_phentsize;
4867 unsigned int num = filedata->file_header.e_phnum;
4868
4869 /* PR binutils/17531: Cope with unexpected section header sizes. */
4870 if (size == 0 || num == 0)
4871 return FALSE;
4872 if (size < sizeof * phdrs)
4873 {
4874 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4875 return FALSE;
4876 }
4877 if (size > sizeof * phdrs)
4878 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4879
4880 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4881 size, num, _("program headers"));
4882 if (phdrs == NULL)
4883 return FALSE;
4884
4885 for (i = 0, internal = pheaders, external = phdrs;
4886 i < filedata->file_header.e_phnum;
4887 i++, internal++, external++)
4888 {
4889 internal->p_type = BYTE_GET (external->p_type);
4890 internal->p_offset = BYTE_GET (external->p_offset);
4891 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4892 internal->p_paddr = BYTE_GET (external->p_paddr);
4893 internal->p_filesz = BYTE_GET (external->p_filesz);
4894 internal->p_memsz = BYTE_GET (external->p_memsz);
4895 internal->p_flags = BYTE_GET (external->p_flags);
4896 internal->p_align = BYTE_GET (external->p_align);
4897 }
4898
4899 free (phdrs);
4900 return TRUE;
4901}
4902
4903/* Read in the program headers from FILEDATA and store them in PHEADERS.
4904 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4905
4906static bfd_boolean
4907get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4908{
4909 Elf64_External_Phdr * phdrs;
4910 Elf64_External_Phdr * external;
4911 Elf_Internal_Phdr * internal;
4912 unsigned int i;
4913 unsigned int size = filedata->file_header.e_phentsize;
4914 unsigned int num = filedata->file_header.e_phnum;
4915
4916 /* PR binutils/17531: Cope with unexpected section header sizes. */
4917 if (size == 0 || num == 0)
4918 return FALSE;
4919 if (size < sizeof * phdrs)
4920 {
4921 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4922 return FALSE;
4923 }
4924 if (size > sizeof * phdrs)
4925 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4926
4927 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4928 size, num, _("program headers"));
4929 if (!phdrs)
4930 return FALSE;
4931
4932 for (i = 0, internal = pheaders, external = phdrs;
4933 i < filedata->file_header.e_phnum;
4934 i++, internal++, external++)
4935 {
4936 internal->p_type = BYTE_GET (external->p_type);
4937 internal->p_flags = BYTE_GET (external->p_flags);
4938 internal->p_offset = BYTE_GET (external->p_offset);
4939 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4940 internal->p_paddr = BYTE_GET (external->p_paddr);
4941 internal->p_filesz = BYTE_GET (external->p_filesz);
4942 internal->p_memsz = BYTE_GET (external->p_memsz);
4943 internal->p_align = BYTE_GET (external->p_align);
4944 }
4945
4946 free (phdrs);
4947 return TRUE;
4948}
4949
4950/* Returns TRUE if the program headers were read into `program_headers'. */
4951
4952static bfd_boolean
4953get_program_headers (Filedata * filedata)
4954{
4955 Elf_Internal_Phdr * phdrs;
4956
4957 /* Check cache of prior read. */
4958 if (filedata->program_headers != NULL)
4959 return TRUE;
4960
4961 /* Be kind to memory checkers by looking for
4962 e_phnum values which we know must be invalid. */
4963 if (filedata->file_header.e_phnum
4964 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4965 >= filedata->file_size)
4966 {
4967 error (_("Too many program headers - %#x - the file is not that big\n"),
4968 filedata->file_header.e_phnum);
4969 return FALSE;
4970 }
4971
4972 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4973 sizeof (Elf_Internal_Phdr));
4974 if (phdrs == NULL)
4975 {
4976 error (_("Out of memory reading %u program headers\n"),
4977 filedata->file_header.e_phnum);
4978 return FALSE;
4979 }
4980
4981 if (is_32bit_elf
4982 ? get_32bit_program_headers (filedata, phdrs)
4983 : get_64bit_program_headers (filedata, phdrs))
4984 {
4985 filedata->program_headers = phdrs;
4986 return TRUE;
4987 }
4988
4989 free (phdrs);
4990 return FALSE;
4991}
4992
4993/* Returns TRUE if the program headers were loaded. */
4994
4995static bfd_boolean
4996process_program_headers (Filedata * filedata)
4997{
4998 Elf_Internal_Phdr * segment;
4999 unsigned int i;
5000 Elf_Internal_Phdr * previous_load = NULL;
5001
5002 if (filedata->file_header.e_phnum == 0)
5003 {
5004 /* PR binutils/12467. */
5005 if (filedata->file_header.e_phoff != 0)
5006 {
5007 warn (_("possibly corrupt ELF header - it has a non-zero program"
5008 " header offset, but no program headers\n"));
5009 return FALSE;
5010 }
5011 else if (do_segments)
5012 printf (_("\nThere are no program headers in this file.\n"));
5013 return TRUE;
5014 }
5015
5016 if (do_segments && !do_header)
5017 {
5018 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5019 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5020 printf (ngettext ("There is %d program header, starting at offset %s\n",
5021 "There are %d program headers, starting at offset %s\n",
5022 filedata->file_header.e_phnum),
5023 filedata->file_header.e_phnum,
5024 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5025 }
5026
5027 if (! get_program_headers (filedata))
5028 return TRUE;
5029
5030 if (do_segments)
5031 {
5032 if (filedata->file_header.e_phnum > 1)
5033 printf (_("\nProgram Headers:\n"));
5034 else
5035 printf (_("\nProgram Headers:\n"));
5036
5037 if (is_32bit_elf)
5038 printf
5039 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5040 else if (do_wide)
5041 printf
5042 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5043 else
5044 {
5045 printf
5046 (_(" Type Offset VirtAddr PhysAddr\n"));
5047 printf
5048 (_(" FileSiz MemSiz Flags Align\n"));
5049 }
5050 }
5051
5052 dynamic_addr = 0;
5053 dynamic_size = 0;
5054
5055 for (i = 0, segment = filedata->program_headers;
5056 i < filedata->file_header.e_phnum;
5057 i++, segment++)
5058 {
5059 if (do_segments)
5060 {
5061 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5062
5063 if (is_32bit_elf)
5064 {
5065 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5066 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5067 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5068 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5069 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5070 printf ("%c%c%c ",
5071 (segment->p_flags & PF_R ? 'R' : ' '),
5072 (segment->p_flags & PF_W ? 'W' : ' '),
5073 (segment->p_flags & PF_X ? 'E' : ' '));
5074 printf ("%#lx", (unsigned long) segment->p_align);
5075 }
5076 else if (do_wide)
5077 {
5078 if ((unsigned long) segment->p_offset == segment->p_offset)
5079 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5080 else
5081 {
5082 print_vma (segment->p_offset, FULL_HEX);
5083 putchar (' ');
5084 }
5085
5086 print_vma (segment->p_vaddr, FULL_HEX);
5087 putchar (' ');
5088 print_vma (segment->p_paddr, FULL_HEX);
5089 putchar (' ');
5090
5091 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5092 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5093 else
5094 {
5095 print_vma (segment->p_filesz, FULL_HEX);
5096 putchar (' ');
5097 }
5098
5099 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5100 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5101 else
5102 {
5103 print_vma (segment->p_memsz, FULL_HEX);
5104 }
5105
5106 printf (" %c%c%c ",
5107 (segment->p_flags & PF_R ? 'R' : ' '),
5108 (segment->p_flags & PF_W ? 'W' : ' '),
5109 (segment->p_flags & PF_X ? 'E' : ' '));
5110
5111 if ((unsigned long) segment->p_align == segment->p_align)
5112 printf ("%#lx", (unsigned long) segment->p_align);
5113 else
5114 {
5115 print_vma (segment->p_align, PREFIX_HEX);
5116 }
5117 }
5118 else
5119 {
5120 print_vma (segment->p_offset, FULL_HEX);
5121 putchar (' ');
5122 print_vma (segment->p_vaddr, FULL_HEX);
5123 putchar (' ');
5124 print_vma (segment->p_paddr, FULL_HEX);
5125 printf ("\n ");
5126 print_vma (segment->p_filesz, FULL_HEX);
5127 putchar (' ');
5128 print_vma (segment->p_memsz, FULL_HEX);
5129 printf (" %c%c%c ",
5130 (segment->p_flags & PF_R ? 'R' : ' '),
5131 (segment->p_flags & PF_W ? 'W' : ' '),
5132 (segment->p_flags & PF_X ? 'E' : ' '));
5133 print_vma (segment->p_align, PREFIX_HEX);
5134 }
5135
5136 putc ('\n', stdout);
5137 }
5138
5139 switch (segment->p_type)
5140 {
5141 case PT_LOAD:
5142#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5143 required by the ELF standard, several programs, including the Linux
5144 kernel, make use of non-ordered segments. */
5145 if (previous_load
5146 && previous_load->p_vaddr > segment->p_vaddr)
5147 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5148#endif
5149 if (segment->p_memsz < segment->p_filesz)
5150 error (_("the segment's file size is larger than its memory size\n"));
5151 previous_load = segment;
5152 break;
5153
5154 case PT_PHDR:
5155 /* PR 20815 - Verify that the program header is loaded into memory. */
5156 if (i > 0 && previous_load != NULL)
5157 error (_("the PHDR segment must occur before any LOAD segment\n"));
5158 if (filedata->file_header.e_machine != EM_PARISC)
5159 {
5160 unsigned int j;
5161
5162 for (j = 1; j < filedata->file_header.e_phnum; j++)
5163 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5164 && (filedata->program_headers[j].p_vaddr
5165 + filedata->program_headers[j].p_memsz)
5166 >= (segment->p_vaddr + segment->p_filesz))
5167 break;
5168 if (j == filedata->file_header.e_phnum)
5169 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5170 }
5171 break;
5172
5173 case PT_DYNAMIC:
5174 if (dynamic_addr)
5175 error (_("more than one dynamic segment\n"));
5176
5177 /* By default, assume that the .dynamic section is the first
5178 section in the DYNAMIC segment. */
5179 dynamic_addr = segment->p_offset;
5180 dynamic_size = segment->p_filesz;
5181
5182 /* Try to locate the .dynamic section. If there is
5183 a section header table, we can easily locate it. */
5184 if (filedata->section_headers != NULL)
5185 {
5186 Elf_Internal_Shdr * sec;
5187
5188 sec = find_section (filedata, ".dynamic");
5189 if (sec == NULL || sec->sh_size == 0)
5190 {
5191 /* A corresponding .dynamic section is expected, but on
5192 IA-64/OpenVMS it is OK for it to be missing. */
5193 if (!is_ia64_vms (filedata))
5194 error (_("no .dynamic section in the dynamic segment\n"));
5195 break;
5196 }
5197
5198 if (sec->sh_type == SHT_NOBITS)
5199 {
5200 dynamic_size = 0;
5201 break;
5202 }
5203
5204 dynamic_addr = sec->sh_offset;
5205 dynamic_size = sec->sh_size;
5206
5207 if (dynamic_addr < segment->p_offset
5208 || dynamic_addr > segment->p_offset + segment->p_filesz)
5209 warn (_("the .dynamic section is not contained"
5210 " within the dynamic segment\n"));
5211 else if (dynamic_addr > segment->p_offset)
5212 warn (_("the .dynamic section is not the first section"
5213 " in the dynamic segment.\n"));
5214 }
5215
5216 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5217 segment. Check this after matching against the section headers
5218 so we don't warn on debuginfo file (which have NOBITS .dynamic
5219 sections). */
5220 if (dynamic_addr + dynamic_size >= filedata->file_size)
5221 {
5222 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5223 dynamic_addr = dynamic_size = 0;
5224 }
5225 break;
5226
5227 case PT_INTERP:
5228 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5229 SEEK_SET))
5230 error (_("Unable to find program interpreter name\n"));
5231 else
5232 {
5233 char fmt [32];
5234 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5235
5236 if (ret >= (int) sizeof (fmt) || ret < 0)
5237 error (_("Internal error: failed to create format string to display program interpreter\n"));
5238
5239 program_interpreter[0] = 0;
5240 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5241 error (_("Unable to read program interpreter name\n"));
5242
5243 if (do_segments)
5244 printf (_(" [Requesting program interpreter: %s]\n"),
5245 program_interpreter);
5246 }
5247 break;
5248 }
5249 }
5250
5251 if (do_segments
5252 && filedata->section_headers != NULL
5253 && filedata->string_table != NULL)
5254 {
5255 printf (_("\n Section to Segment mapping:\n"));
5256 printf (_(" Segment Sections...\n"));
5257
5258 for (i = 0; i < filedata->file_header.e_phnum; i++)
5259 {
5260 unsigned int j;
5261 Elf_Internal_Shdr * section;
5262
5263 segment = filedata->program_headers + i;
5264 section = filedata->section_headers + 1;
5265
5266 printf (" %2.2d ", i);
5267
5268 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5269 {
5270 if (!ELF_TBSS_SPECIAL (section, segment)
5271 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5272 printf ("%s ", printable_section_name (filedata, section));
5273 }
5274
5275 putc ('\n',stdout);
5276 }
5277 }
5278
5279 return TRUE;
5280}
5281
5282
5283/* Find the file offset corresponding to VMA by using the program headers. */
5284
5285static long
5286offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5287{
5288 Elf_Internal_Phdr * seg;
5289
5290 if (! get_program_headers (filedata))
5291 {
5292 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5293 return (long) vma;
5294 }
5295
5296 for (seg = filedata->program_headers;
5297 seg < filedata->program_headers + filedata->file_header.e_phnum;
5298 ++seg)
5299 {
5300 if (seg->p_type != PT_LOAD)
5301 continue;
5302
5303 if (vma >= (seg->p_vaddr & -seg->p_align)
5304 && vma + size <= seg->p_vaddr + seg->p_filesz)
5305 return vma - seg->p_vaddr + seg->p_offset;
5306 }
5307
5308 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5309 (unsigned long) vma);
5310 return (long) vma;
5311}
5312
5313
5314/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5315 If PROBE is true, this is just a probe and we do not generate any error
5316 messages if the load fails. */
5317
5318static bfd_boolean
5319get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5320{
5321 Elf32_External_Shdr * shdrs;
5322 Elf_Internal_Shdr * internal;
5323 unsigned int i;
5324 unsigned int size = filedata->file_header.e_shentsize;
5325 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5326
5327 /* PR binutils/17531: Cope with unexpected section header sizes. */
5328 if (size == 0 || num == 0)
5329 return FALSE;
5330 if (size < sizeof * shdrs)
5331 {
5332 if (! probe)
5333 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5334 return FALSE;
5335 }
5336 if (!probe && size > sizeof * shdrs)
5337 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5338
5339 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5340 size, num,
5341 probe ? NULL : _("section headers"));
5342 if (shdrs == NULL)
5343 return FALSE;
5344
5345 free (filedata->section_headers);
5346 filedata->section_headers = (Elf_Internal_Shdr *)
5347 cmalloc (num, sizeof (Elf_Internal_Shdr));
5348 if (filedata->section_headers == NULL)
5349 {
5350 if (!probe)
5351 error (_("Out of memory reading %u section headers\n"), num);
5352 free (shdrs);
5353 return FALSE;
5354 }
5355
5356 for (i = 0, internal = filedata->section_headers;
5357 i < num;
5358 i++, internal++)
5359 {
5360 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5361 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5362 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5363 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5364 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5365 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5366 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5367 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5368 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5369 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5370 if (!probe && internal->sh_link > num)
5371 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5372 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5373 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5374 }
5375
5376 free (shdrs);
5377 return TRUE;
5378}
5379
5380/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5381
5382static bfd_boolean
5383get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5384{
5385 Elf64_External_Shdr * shdrs;
5386 Elf_Internal_Shdr * internal;
5387 unsigned int i;
5388 unsigned int size = filedata->file_header.e_shentsize;
5389 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5390
5391 /* PR binutils/17531: Cope with unexpected section header sizes. */
5392 if (size == 0 || num == 0)
5393 return FALSE;
5394
5395 if (size < sizeof * shdrs)
5396 {
5397 if (! probe)
5398 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5399 return FALSE;
5400 }
5401
5402 if (! probe && size > sizeof * shdrs)
5403 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5404
5405 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5406 filedata->file_header.e_shoff,
5407 size, num,
5408 probe ? NULL : _("section headers"));
5409 if (shdrs == NULL)
5410 return FALSE;
5411
5412 free (filedata->section_headers);
5413 filedata->section_headers = (Elf_Internal_Shdr *)
5414 cmalloc (num, sizeof (Elf_Internal_Shdr));
5415 if (filedata->section_headers == NULL)
5416 {
5417 if (! probe)
5418 error (_("Out of memory reading %u section headers\n"), num);
5419 free (shdrs);
5420 return FALSE;
5421 }
5422
5423 for (i = 0, internal = filedata->section_headers;
5424 i < num;
5425 i++, internal++)
5426 {
5427 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5428 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5429 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5430 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5431 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5432 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5433 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5434 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5435 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5436 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5437 if (!probe && internal->sh_link > num)
5438 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5439 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5440 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5441 }
5442
5443 free (shdrs);
5444 return TRUE;
5445}
5446
5447static Elf_Internal_Sym *
5448get_32bit_elf_symbols (Filedata * filedata,
5449 Elf_Internal_Shdr * section,
5450 unsigned long * num_syms_return)
5451{
5452 unsigned long number = 0;
5453 Elf32_External_Sym * esyms = NULL;
5454 Elf_External_Sym_Shndx * shndx = NULL;
5455 Elf_Internal_Sym * isyms = NULL;
5456 Elf_Internal_Sym * psym;
5457 unsigned int j;
5458 elf_section_list * entry;
5459
5460 if (section->sh_size == 0)
5461 {
5462 if (num_syms_return != NULL)
5463 * num_syms_return = 0;
5464 return NULL;
5465 }
5466
5467 /* Run some sanity checks first. */
5468 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5469 {
5470 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5471 printable_section_name (filedata, section),
5472 (unsigned long) section->sh_entsize);
5473 goto exit_point;
5474 }
5475
5476 if (section->sh_size > filedata->file_size)
5477 {
5478 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5479 printable_section_name (filedata, section),
5480 (unsigned long) section->sh_size);
5481 goto exit_point;
5482 }
5483
5484 number = section->sh_size / section->sh_entsize;
5485
5486 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5487 {
5488 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5489 (unsigned long) section->sh_size,
5490 printable_section_name (filedata, section),
5491 (unsigned long) section->sh_entsize);
5492 goto exit_point;
5493 }
5494
5495 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5496 section->sh_size, _("symbols"));
5497 if (esyms == NULL)
5498 goto exit_point;
5499
5500 shndx = NULL;
5501 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5502 {
5503 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5504 continue;
5505
5506 if (shndx != NULL)
5507 {
5508 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5509 free (shndx);
5510 }
5511
5512 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5513 entry->hdr->sh_offset,
5514 1, entry->hdr->sh_size,
5515 _("symbol table section indices"));
5516 if (shndx == NULL)
5517 goto exit_point;
5518
5519 /* PR17531: file: heap-buffer-overflow */
5520 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5521 {
5522 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5523 printable_section_name (filedata, entry->hdr),
5524 (unsigned long) entry->hdr->sh_size,
5525 (unsigned long) section->sh_size);
5526 goto exit_point;
5527 }
5528 }
5529
5530 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5531
5532 if (isyms == NULL)
5533 {
5534 error (_("Out of memory reading %lu symbols\n"),
5535 (unsigned long) number);
5536 goto exit_point;
5537 }
5538
5539 for (j = 0, psym = isyms; j < number; j++, psym++)
5540 {
5541 psym->st_name = BYTE_GET (esyms[j].st_name);
5542 psym->st_value = BYTE_GET (esyms[j].st_value);
5543 psym->st_size = BYTE_GET (esyms[j].st_size);
5544 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5545 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5546 psym->st_shndx
5547 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5548 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5549 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5550 psym->st_info = BYTE_GET (esyms[j].st_info);
5551 psym->st_other = BYTE_GET (esyms[j].st_other);
5552 }
5553
5554 exit_point:
5555 free (shndx);
5556 free (esyms);
5557
5558 if (num_syms_return != NULL)
5559 * num_syms_return = isyms == NULL ? 0 : number;
5560
5561 return isyms;
5562}
5563
5564static Elf_Internal_Sym *
5565get_64bit_elf_symbols (Filedata * filedata,
5566 Elf_Internal_Shdr * section,
5567 unsigned long * num_syms_return)
5568{
5569 unsigned long number = 0;
5570 Elf64_External_Sym * esyms = NULL;
5571 Elf_External_Sym_Shndx * shndx = NULL;
5572 Elf_Internal_Sym * isyms = NULL;
5573 Elf_Internal_Sym * psym;
5574 unsigned int j;
5575 elf_section_list * entry;
5576
5577 if (section->sh_size == 0)
5578 {
5579 if (num_syms_return != NULL)
5580 * num_syms_return = 0;
5581 return NULL;
5582 }
5583
5584 /* Run some sanity checks first. */
5585 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5586 {
5587 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5588 printable_section_name (filedata, section),
5589 (unsigned long) section->sh_entsize);
5590 goto exit_point;
5591 }
5592
5593 if (section->sh_size > filedata->file_size)
5594 {
5595 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5596 printable_section_name (filedata, section),
5597 (unsigned long) section->sh_size);
5598 goto exit_point;
5599 }
5600
5601 number = section->sh_size / section->sh_entsize;
5602
5603 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5604 {
5605 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5606 (unsigned long) section->sh_size,
5607 printable_section_name (filedata, section),
5608 (unsigned long) section->sh_entsize);
5609 goto exit_point;
5610 }
5611
5612 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5613 section->sh_size, _("symbols"));
5614 if (!esyms)
5615 goto exit_point;
5616
5617 shndx = NULL;
5618 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5619 {
5620 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5621 continue;
5622
5623 if (shndx != NULL)
5624 {
5625 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5626 free (shndx);
5627 }
5628
5629 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5630 entry->hdr->sh_offset,
5631 1, entry->hdr->sh_size,
5632 _("symbol table section indices"));
5633 if (shndx == NULL)
5634 goto exit_point;
5635
5636 /* PR17531: file: heap-buffer-overflow */
5637 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5638 {
5639 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5640 printable_section_name (filedata, entry->hdr),
5641 (unsigned long) entry->hdr->sh_size,
5642 (unsigned long) section->sh_size);
5643 goto exit_point;
5644 }
5645 }
5646
5647 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5648
5649 if (isyms == NULL)
5650 {
5651 error (_("Out of memory reading %lu symbols\n"),
5652 (unsigned long) number);
5653 goto exit_point;
5654 }
5655
5656 for (j = 0, psym = isyms; j < number; j++, psym++)
5657 {
5658 psym->st_name = BYTE_GET (esyms[j].st_name);
5659 psym->st_info = BYTE_GET (esyms[j].st_info);
5660 psym->st_other = BYTE_GET (esyms[j].st_other);
5661 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5662
5663 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5664 psym->st_shndx
5665 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5666 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5667 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5668
5669 psym->st_value = BYTE_GET (esyms[j].st_value);
5670 psym->st_size = BYTE_GET (esyms[j].st_size);
5671 }
5672
5673 exit_point:
5674 free (shndx);
5675 free (esyms);
5676
5677 if (num_syms_return != NULL)
5678 * num_syms_return = isyms == NULL ? 0 : number;
5679
5680 return isyms;
5681}
5682
5683static const char *
5684get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5685{
5686 static char buff[1024];
5687 char * p = buff;
5688 unsigned int field_size = is_32bit_elf ? 8 : 16;
5689 signed int sindex;
5690 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5691 bfd_vma os_flags = 0;
5692 bfd_vma proc_flags = 0;
5693 bfd_vma unknown_flags = 0;
5694 static const struct
5695 {
5696 const char * str;
5697 unsigned int len;
5698 }
5699 flags [] =
5700 {
5701 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5702 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5703 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5704 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5705 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5706 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5707 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5708 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5709 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5710 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5711 /* IA-64 specific. */
5712 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5713 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5714 /* IA-64 OpenVMS specific. */
5715 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5716 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5717 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5718 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5719 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5720 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5721 /* Generic. */
5722 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5723 /* SPARC specific. */
5724 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5725 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5726 /* ARM specific. */
5727 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5728 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5729 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5730 /* GNU specific. */
5731 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5732 /* VLE specific. */
5733 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5734 };
5735
5736 if (do_section_details)
5737 {
5738 sprintf (buff, "[%*.*lx]: ",
5739 field_size, field_size, (unsigned long) sh_flags);
5740 p += field_size + 4;
5741 }
5742
5743 while (sh_flags)
5744 {
5745 bfd_vma flag;
5746
5747 flag = sh_flags & - sh_flags;
5748 sh_flags &= ~ flag;
5749
5750 if (do_section_details)
5751 {
5752 switch (flag)
5753 {
5754 case SHF_WRITE: sindex = 0; break;
5755 case SHF_ALLOC: sindex = 1; break;
5756 case SHF_EXECINSTR: sindex = 2; break;
5757 case SHF_MERGE: sindex = 3; break;
5758 case SHF_STRINGS: sindex = 4; break;
5759 case SHF_INFO_LINK: sindex = 5; break;
5760 case SHF_LINK_ORDER: sindex = 6; break;
5761 case SHF_OS_NONCONFORMING: sindex = 7; break;
5762 case SHF_GROUP: sindex = 8; break;
5763 case SHF_TLS: sindex = 9; break;
5764 case SHF_EXCLUDE: sindex = 18; break;
5765 case SHF_COMPRESSED: sindex = 20; break;
5766 case SHF_GNU_MBIND: sindex = 24; break;
5767
5768 default:
5769 sindex = -1;
5770 switch (filedata->file_header.e_machine)
5771 {
5772 case EM_IA_64:
5773 if (flag == SHF_IA_64_SHORT)
5774 sindex = 10;
5775 else if (flag == SHF_IA_64_NORECOV)
5776 sindex = 11;
5777#ifdef BFD64
5778 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5779 switch (flag)
5780 {
5781 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5782 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5783 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5784 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5785 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5786 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5787 default: break;
5788 }
5789#endif
5790 break;
5791
5792 case EM_386:
5793 case EM_IAMCU:
5794 case EM_X86_64:
5795 case EM_L1OM:
5796 case EM_K1OM:
5797 case EM_OLD_SPARCV9:
5798 case EM_SPARC32PLUS:
5799 case EM_SPARCV9:
5800 case EM_SPARC:
5801 if (flag == SHF_ORDERED)
5802 sindex = 19;
5803 break;
5804
5805 case EM_ARM:
5806 switch (flag)
5807 {
5808 case SHF_ENTRYSECT: sindex = 21; break;
5809 case SHF_ARM_PURECODE: sindex = 22; break;
5810 case SHF_COMDEF: sindex = 23; break;
5811 default: break;
5812 }
5813 break;
5814 case EM_PPC:
5815 if (flag == SHF_PPC_VLE)
5816 sindex = 25;
5817 break;
5818
5819 default:
5820 break;
5821 }
5822 }
5823
5824 if (sindex != -1)
5825 {
5826 if (p != buff + field_size + 4)
5827 {
5828 if (size < (10 + 2))
5829 {
5830 warn (_("Internal error: not enough buffer room for section flag info"));
5831 return _("<unknown>");
5832 }
5833 size -= 2;
5834 *p++ = ',';
5835 *p++ = ' ';
5836 }
5837
5838 size -= flags [sindex].len;
5839 p = stpcpy (p, flags [sindex].str);
5840 }
5841 else if (flag & SHF_MASKOS)
5842 os_flags |= flag;
5843 else if (flag & SHF_MASKPROC)
5844 proc_flags |= flag;
5845 else
5846 unknown_flags |= flag;
5847 }
5848 else
5849 {
5850 switch (flag)
5851 {
5852 case SHF_WRITE: *p = 'W'; break;
5853 case SHF_ALLOC: *p = 'A'; break;
5854 case SHF_EXECINSTR: *p = 'X'; break;
5855 case SHF_MERGE: *p = 'M'; break;
5856 case SHF_STRINGS: *p = 'S'; break;
5857 case SHF_INFO_LINK: *p = 'I'; break;
5858 case SHF_LINK_ORDER: *p = 'L'; break;
5859 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5860 case SHF_GROUP: *p = 'G'; break;
5861 case SHF_TLS: *p = 'T'; break;
5862 case SHF_EXCLUDE: *p = 'E'; break;
5863 case SHF_COMPRESSED: *p = 'C'; break;
5864 case SHF_GNU_MBIND: *p = 'D'; break;
5865
5866 default:
5867 if ((filedata->file_header.e_machine == EM_X86_64
5868 || filedata->file_header.e_machine == EM_L1OM
5869 || filedata->file_header.e_machine == EM_K1OM)
5870 && flag == SHF_X86_64_LARGE)
5871 *p = 'l';
5872 else if (filedata->file_header.e_machine == EM_ARM
5873 && flag == SHF_ARM_PURECODE)
5874 *p = 'y';
5875 else if (filedata->file_header.e_machine == EM_PPC
5876 && flag == SHF_PPC_VLE)
5877 *p = 'v';
5878 else if (flag & SHF_MASKOS)
5879 {
5880 *p = 'o';
5881 sh_flags &= ~ SHF_MASKOS;
5882 }
5883 else if (flag & SHF_MASKPROC)
5884 {
5885 *p = 'p';
5886 sh_flags &= ~ SHF_MASKPROC;
5887 }
5888 else
5889 *p = 'x';
5890 break;
5891 }
5892 p++;
5893 }
5894 }
5895
5896 if (do_section_details)
5897 {
5898 if (os_flags)
5899 {
5900 size -= 5 + field_size;
5901 if (p != buff + field_size + 4)
5902 {
5903 if (size < (2 + 1))
5904 {
5905 warn (_("Internal error: not enough buffer room for section flag info"));
5906 return _("<unknown>");
5907 }
5908 size -= 2;
5909 *p++ = ',';
5910 *p++ = ' ';
5911 }
5912 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5913 (unsigned long) os_flags);
5914 p += 5 + field_size;
5915 }
5916 if (proc_flags)
5917 {
5918 size -= 7 + field_size;
5919 if (p != buff + field_size + 4)
5920 {
5921 if (size < (2 + 1))
5922 {
5923 warn (_("Internal error: not enough buffer room for section flag info"));
5924 return _("<unknown>");
5925 }
5926 size -= 2;
5927 *p++ = ',';
5928 *p++ = ' ';
5929 }
5930 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5931 (unsigned long) proc_flags);
5932 p += 7 + field_size;
5933 }
5934 if (unknown_flags)
5935 {
5936 size -= 10 + field_size;
5937 if (p != buff + field_size + 4)
5938 {
5939 if (size < (2 + 1))
5940 {
5941 warn (_("Internal error: not enough buffer room for section flag info"));
5942 return _("<unknown>");
5943 }
5944 size -= 2;
5945 *p++ = ',';
5946 *p++ = ' ';
5947 }
5948 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5949 (unsigned long) unknown_flags);
5950 p += 10 + field_size;
5951 }
5952 }
5953
5954 *p = '\0';
5955 return buff;
5956}
5957
5958static unsigned int
5959get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5960{
5961 if (is_32bit_elf)
5962 {
5963 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5964
5965 if (size < sizeof (* echdr))
5966 {
5967 error (_("Compressed section is too small even for a compression header\n"));
5968 return 0;
5969 }
5970
5971 chdr->ch_type = BYTE_GET (echdr->ch_type);
5972 chdr->ch_size = BYTE_GET (echdr->ch_size);
5973 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5974 return sizeof (*echdr);
5975 }
5976 else
5977 {
5978 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5979
5980 if (size < sizeof (* echdr))
5981 {
5982 error (_("Compressed section is too small even for a compression header\n"));
5983 return 0;
5984 }
5985
5986 chdr->ch_type = BYTE_GET (echdr->ch_type);
5987 chdr->ch_size = BYTE_GET (echdr->ch_size);
5988 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5989 return sizeof (*echdr);
5990 }
5991}
5992
5993static bfd_boolean
5994process_section_headers (Filedata * filedata)
5995{
5996 Elf_Internal_Shdr * section;
5997 unsigned int i;
5998
5999 filedata->section_headers = NULL;
6000
6001 if (filedata->file_header.e_shnum == 0)
6002 {
6003 /* PR binutils/12467. */
6004 if (filedata->file_header.e_shoff != 0)
6005 {
6006 warn (_("possibly corrupt ELF file header - it has a non-zero"
6007 " section header offset, but no section headers\n"));
6008 return FALSE;
6009 }
6010 else if (do_sections)
6011 printf (_("\nThere are no sections in this file.\n"));
6012
6013 return TRUE;
6014 }
6015
6016 if (do_sections && !do_header)
6017 printf (ngettext ("There is %d section header, "
6018 "starting at offset 0x%lx:\n",
6019 "There are %d section headers, "
6020 "starting at offset 0x%lx:\n",
6021 filedata->file_header.e_shnum),
6022 filedata->file_header.e_shnum,
6023 (unsigned long) filedata->file_header.e_shoff);
6024
6025 if (is_32bit_elf)
6026 {
6027 if (! get_32bit_section_headers (filedata, FALSE))
6028 return FALSE;
6029 }
6030 else
6031 {
6032 if (! get_64bit_section_headers (filedata, FALSE))
6033 return FALSE;
6034 }
6035
6036 /* Read in the string table, so that we have names to display. */
6037 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6038 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6039 {
6040 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6041
6042 if (section->sh_size != 0)
6043 {
6044 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6045 1, section->sh_size,
6046 _("string table"));
6047
6048 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6049 }
6050 }
6051
6052 /* Scan the sections for the dynamic symbol table
6053 and dynamic string table and debug sections. */
6054 dynamic_symbols = NULL;
6055 dynamic_strings = NULL;
6056 dynamic_syminfo = NULL;
6057 symtab_shndx_list = NULL;
6058
6059 eh_addr_size = is_32bit_elf ? 4 : 8;
6060 switch (filedata->file_header.e_machine)
6061 {
6062 case EM_MIPS:
6063 case EM_MIPS_RS3_LE:
6064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6065 FDE addresses. However, the ABI also has a semi-official ILP32
6066 variant for which the normal FDE address size rules apply.
6067
6068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6069 section, where XX is the size of longs in bits. Unfortunately,
6070 earlier compilers provided no way of distinguishing ILP32 objects
6071 from LP64 objects, so if there's any doubt, we should assume that
6072 the official LP64 form is being used. */
6073 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6074 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6075 eh_addr_size = 8;
6076 break;
6077
6078 case EM_H8_300:
6079 case EM_H8_300H:
6080 switch (filedata->file_header.e_flags & EF_H8_MACH)
6081 {
6082 case E_H8_MACH_H8300:
6083 case E_H8_MACH_H8300HN:
6084 case E_H8_MACH_H8300SN:
6085 case E_H8_MACH_H8300SXN:
6086 eh_addr_size = 2;
6087 break;
6088 case E_H8_MACH_H8300H:
6089 case E_H8_MACH_H8300S:
6090 case E_H8_MACH_H8300SX:
6091 eh_addr_size = 4;
6092 break;
6093 }
6094 break;
6095
6096 case EM_M32C_OLD:
6097 case EM_M32C:
6098 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6099 {
6100 case EF_M32C_CPU_M16C:
6101 eh_addr_size = 2;
6102 break;
6103 }
6104 break;
6105 }
6106
6107#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6108 do \
6109 { \
6110 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6111 if (section->sh_entsize != expected_entsize) \
6112 { \
6113 char buf[40]; \
6114 sprintf_vma (buf, section->sh_entsize); \
6115 /* Note: coded this way so that there is a single string for \
6116 translation. */ \
6117 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6118 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6119 (unsigned) expected_entsize); \
6120 section->sh_entsize = expected_entsize; \
6121 } \
6122 } \
6123 while (0)
6124
6125#define CHECK_ENTSIZE(section, i, type) \
6126 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6127 sizeof (Elf64_External_##type))
6128
6129 for (i = 0, section = filedata->section_headers;
6130 i < filedata->file_header.e_shnum;
6131 i++, section++)
6132 {
6133 char * name = SECTION_NAME (section);
6134
6135 if (section->sh_type == SHT_DYNSYM)
6136 {
6137 if (dynamic_symbols != NULL)
6138 {
6139 error (_("File contains multiple dynamic symbol tables\n"));
6140 continue;
6141 }
6142
6143 CHECK_ENTSIZE (section, i, Sym);
6144 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6145 }
6146 else if (section->sh_type == SHT_STRTAB
6147 && streq (name, ".dynstr"))
6148 {
6149 if (dynamic_strings != NULL)
6150 {
6151 error (_("File contains multiple dynamic string tables\n"));
6152 continue;
6153 }
6154
6155 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6156 1, section->sh_size,
6157 _("dynamic strings"));
6158 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6159 }
6160 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6161 {
6162 elf_section_list * entry = xmalloc (sizeof * entry);
6163
6164 entry->hdr = section;
6165 entry->next = symtab_shndx_list;
6166 symtab_shndx_list = entry;
6167 }
6168 else if (section->sh_type == SHT_SYMTAB)
6169 CHECK_ENTSIZE (section, i, Sym);
6170 else if (section->sh_type == SHT_GROUP)
6171 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6172 else if (section->sh_type == SHT_REL)
6173 CHECK_ENTSIZE (section, i, Rel);
6174 else if (section->sh_type == SHT_RELA)
6175 CHECK_ENTSIZE (section, i, Rela);
6176 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6177 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6178 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6179 || do_debug_str || do_debug_loc || do_debug_ranges
6180 || do_debug_addr || do_debug_cu_index || do_debug_links)
6181 && (const_strneq (name, ".debug_")
6182 || const_strneq (name, ".zdebug_")))
6183 {
6184 if (name[1] == 'z')
6185 name += sizeof (".zdebug_") - 1;
6186 else
6187 name += sizeof (".debug_") - 1;
6188
6189 if (do_debugging
6190 || (do_debug_info && const_strneq (name, "info"))
6191 || (do_debug_info && const_strneq (name, "types"))
6192 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6193 || (do_debug_lines && strcmp (name, "line") == 0)
6194 || (do_debug_lines && const_strneq (name, "line."))
6195 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6196 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6197 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6198 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6199 || (do_debug_aranges && const_strneq (name, "aranges"))
6200 || (do_debug_ranges && const_strneq (name, "ranges"))
6201 || (do_debug_ranges && const_strneq (name, "rnglists"))
6202 || (do_debug_frames && const_strneq (name, "frame"))
6203 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6204 || (do_debug_macinfo && const_strneq (name, "macro"))
6205 || (do_debug_str && const_strneq (name, "str"))
6206 || (do_debug_loc && const_strneq (name, "loc"))
6207 || (do_debug_loc && const_strneq (name, "loclists"))
6208 || (do_debug_addr && const_strneq (name, "addr"))
6209 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6210 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6211 )
6212 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6213 }
6214 /* Linkonce section to be combined with .debug_info at link time. */
6215 else if ((do_debugging || do_debug_info)
6216 && const_strneq (name, ".gnu.linkonce.wi."))
6217 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6218 else if (do_debug_frames && streq (name, ".eh_frame"))
6219 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220 else if (do_gdb_index && (streq (name, ".gdb_index")
6221 || streq (name, ".debug_names")))
6222 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6223 /* Trace sections for Itanium VMS. */
6224 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6225 || do_trace_aranges)
6226 && const_strneq (name, ".trace_"))
6227 {
6228 name += sizeof (".trace_") - 1;
6229
6230 if (do_debugging
6231 || (do_trace_info && streq (name, "info"))
6232 || (do_trace_abbrevs && streq (name, "abbrev"))
6233 || (do_trace_aranges && streq (name, "aranges"))
6234 )
6235 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6236 }
6237 else if ((do_debugging || do_debug_links)
6238 && (const_strneq (name, ".gnu_debuglink")
6239 || const_strneq (name, ".gnu_debugaltlink")))
6240 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6241 }
6242
6243 if (! do_sections)
6244 return TRUE;
6245
6246 if (filedata->file_header.e_shnum > 1)
6247 printf (_("\nSection Headers:\n"));
6248 else
6249 printf (_("\nSection Header:\n"));
6250
6251 if (is_32bit_elf)
6252 {
6253 if (do_section_details)
6254 {
6255 printf (_(" [Nr] Name\n"));
6256 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6257 }
6258 else
6259 printf
6260 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6261 }
6262 else if (do_wide)
6263 {
6264 if (do_section_details)
6265 {
6266 printf (_(" [Nr] Name\n"));
6267 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6268 }
6269 else
6270 printf
6271 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6272 }
6273 else
6274 {
6275 if (do_section_details)
6276 {
6277 printf (_(" [Nr] Name\n"));
6278 printf (_(" Type Address Offset Link\n"));
6279 printf (_(" Size EntSize Info Align\n"));
6280 }
6281 else
6282 {
6283 printf (_(" [Nr] Name Type Address Offset\n"));
6284 printf (_(" Size EntSize Flags Link Info Align\n"));
6285 }
6286 }
6287
6288 if (do_section_details)
6289 printf (_(" Flags\n"));
6290
6291 for (i = 0, section = filedata->section_headers;
6292 i < filedata->file_header.e_shnum;
6293 i++, section++)
6294 {
6295 /* Run some sanity checks on the section header. */
6296
6297 /* Check the sh_link field. */
6298 switch (section->sh_type)
6299 {
6300 case SHT_SYMTAB_SHNDX:
6301 case SHT_GROUP:
6302 case SHT_HASH:
6303 case SHT_GNU_HASH:
6304 case SHT_GNU_versym:
6305 case SHT_REL:
6306 case SHT_RELA:
6307 if (section->sh_link < 1
6308 || section->sh_link >= filedata->file_header.e_shnum
6309 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6310 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6311 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6312 i, section->sh_link);
6313 break;
6314
6315 case SHT_DYNAMIC:
6316 case SHT_SYMTAB:
6317 case SHT_DYNSYM:
6318 case SHT_GNU_verneed:
6319 case SHT_GNU_verdef:
6320 case SHT_GNU_LIBLIST:
6321 if (section->sh_link < 1
6322 || section->sh_link >= filedata->file_header.e_shnum
6323 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6324 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6325 i, section->sh_link);
6326 break;
6327
6328 case SHT_INIT_ARRAY:
6329 case SHT_FINI_ARRAY:
6330 case SHT_PREINIT_ARRAY:
6331 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6332 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6333 i, section->sh_link);
6334 break;
6335
6336 default:
6337 /* FIXME: Add support for target specific section types. */
6338#if 0 /* Currently we do not check other section types as there are too
6339 many special cases. Stab sections for example have a type
6340 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6341 section. */
6342 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6343 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6344 i, section->sh_link);
6345#endif
6346 break;
6347 }
6348
6349 /* Check the sh_info field. */
6350 switch (section->sh_type)
6351 {
6352 case SHT_REL:
6353 case SHT_RELA:
6354 if (section->sh_info < 1
6355 || section->sh_info >= filedata->file_header.e_shnum
6356 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6357 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6358 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6359 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6360 /* FIXME: Are other section types valid ? */
6361 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6362 {
6363 if (section->sh_info == 0
6364 && (filedata->file_header.e_type == ET_EXEC
6365 || filedata->file_header.e_type == ET_DYN
6366 /* These next two tests may be redundant, but
6367 they have been left in for paranoia's sake. */
6368 || streq (SECTION_NAME (section), ".rel.dyn")
6369 || streq (SECTION_NAME (section), ".rela.dyn")))
6370 /* Dynamic relocations apply to segments, not sections, so
6371 they do not need an sh_info value. */
6372 ;
6373 else
6374 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6375 i, section->sh_info);
6376 }
6377 break;
6378
6379 case SHT_DYNAMIC:
6380 case SHT_HASH:
6381 case SHT_SYMTAB_SHNDX:
6382 case SHT_INIT_ARRAY:
6383 case SHT_FINI_ARRAY:
6384 case SHT_PREINIT_ARRAY:
6385 if (section->sh_info != 0)
6386 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6387 i, section->sh_info);
6388 break;
6389
6390 case SHT_GROUP:
6391 case SHT_SYMTAB:
6392 case SHT_DYNSYM:
6393 /* A symbol index - we assume that it is valid. */
6394 break;
6395
6396 default:
6397 /* FIXME: Add support for target specific section types. */
6398 if (section->sh_type == SHT_NOBITS)
6399 /* NOBITS section headers with non-zero sh_info fields can be
6400 created when a binary is stripped of everything but its debug
6401 information. The stripped sections have their headers
6402 preserved but their types set to SHT_NOBITS. So do not check
6403 this type of section. */
6404 ;
6405 else if (section->sh_flags & SHF_INFO_LINK)
6406 {
6407 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6408 warn (_("[%2u]: Expected link to another section in info field"), i);
6409 }
6410 else if (section->sh_type < SHT_LOOS
6411 && (section->sh_flags & SHF_GNU_MBIND) == 0
6412 && section->sh_info != 0)
6413 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6414 i, section->sh_info);
6415 break;
6416 }
6417
6418 /* Check the sh_size field. */
6419 if (section->sh_size > filedata->file_size
6420 && section->sh_type != SHT_NOBITS
6421 && section->sh_type != SHT_NULL
6422 && section->sh_type < SHT_LOOS)
6423 warn (_("Size of section %u is larger than the entire file!\n"), i);
6424
6425 printf (" [%2u] ", i);
6426 if (do_section_details)
6427 printf ("%s\n ", printable_section_name (filedata, section));
6428 else
6429 print_symbol (-17, SECTION_NAME (section));
6430
6431 printf (do_wide ? " %-15s " : " %-15.15s ",
6432 get_section_type_name (filedata, section->sh_type));
6433
6434 if (is_32bit_elf)
6435 {
6436 const char * link_too_big = NULL;
6437
6438 print_vma (section->sh_addr, LONG_HEX);
6439
6440 printf ( " %6.6lx %6.6lx %2.2lx",
6441 (unsigned long) section->sh_offset,
6442 (unsigned long) section->sh_size,
6443 (unsigned long) section->sh_entsize);
6444
6445 if (do_section_details)
6446 fputs (" ", stdout);
6447 else
6448 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6449
6450 if (section->sh_link >= filedata->file_header.e_shnum)
6451 {
6452 link_too_big = "";
6453 /* The sh_link value is out of range. Normally this indicates
6454 an error but it can have special values in Solaris binaries. */
6455 switch (filedata->file_header.e_machine)
6456 {
6457 case EM_386:
6458 case EM_IAMCU:
6459 case EM_X86_64:
6460 case EM_L1OM:
6461 case EM_K1OM:
6462 case EM_OLD_SPARCV9:
6463 case EM_SPARC32PLUS:
6464 case EM_SPARCV9:
6465 case EM_SPARC:
6466 if (section->sh_link == (SHN_BEFORE & 0xffff))
6467 link_too_big = "BEFORE";
6468 else if (section->sh_link == (SHN_AFTER & 0xffff))
6469 link_too_big = "AFTER";
6470 break;
6471 default:
6472 break;
6473 }
6474 }
6475
6476 if (do_section_details)
6477 {
6478 if (link_too_big != NULL && * link_too_big)
6479 printf ("<%s> ", link_too_big);
6480 else
6481 printf ("%2u ", section->sh_link);
6482 printf ("%3u %2lu\n", section->sh_info,
6483 (unsigned long) section->sh_addralign);
6484 }
6485 else
6486 printf ("%2u %3u %2lu\n",
6487 section->sh_link,
6488 section->sh_info,
6489 (unsigned long) section->sh_addralign);
6490
6491 if (link_too_big && ! * link_too_big)
6492 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6493 i, section->sh_link);
6494 }
6495 else if (do_wide)
6496 {
6497 print_vma (section->sh_addr, LONG_HEX);
6498
6499 if ((long) section->sh_offset == section->sh_offset)
6500 printf (" %6.6lx", (unsigned long) section->sh_offset);
6501 else
6502 {
6503 putchar (' ');
6504 print_vma (section->sh_offset, LONG_HEX);
6505 }
6506
6507 if ((unsigned long) section->sh_size == section->sh_size)
6508 printf (" %6.6lx", (unsigned long) section->sh_size);
6509 else
6510 {
6511 putchar (' ');
6512 print_vma (section->sh_size, LONG_HEX);
6513 }
6514
6515 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6516 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6517 else
6518 {
6519 putchar (' ');
6520 print_vma (section->sh_entsize, LONG_HEX);
6521 }
6522
6523 if (do_section_details)
6524 fputs (" ", stdout);
6525 else
6526 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6527
6528 printf ("%2u %3u ", section->sh_link, section->sh_info);
6529
6530 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6531 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6532 else
6533 {
6534 print_vma (section->sh_addralign, DEC);
6535 putchar ('\n');
6536 }
6537 }
6538 else if (do_section_details)
6539 {
6540 putchar (' ');
6541 print_vma (section->sh_addr, LONG_HEX);
6542 if ((long) section->sh_offset == section->sh_offset)
6543 printf (" %16.16lx", (unsigned long) section->sh_offset);
6544 else
6545 {
6546 printf (" ");
6547 print_vma (section->sh_offset, LONG_HEX);
6548 }
6549 printf (" %u\n ", section->sh_link);
6550 print_vma (section->sh_size, LONG_HEX);
6551 putchar (' ');
6552 print_vma (section->sh_entsize, LONG_HEX);
6553
6554 printf (" %-16u %lu\n",
6555 section->sh_info,
6556 (unsigned long) section->sh_addralign);
6557 }
6558 else
6559 {
6560 putchar (' ');
6561 print_vma (section->sh_addr, LONG_HEX);
6562 if ((long) section->sh_offset == section->sh_offset)
6563 printf (" %8.8lx", (unsigned long) section->sh_offset);
6564 else
6565 {
6566 printf (" ");
6567 print_vma (section->sh_offset, LONG_HEX);
6568 }
6569 printf ("\n ");
6570 print_vma (section->sh_size, LONG_HEX);
6571 printf (" ");
6572 print_vma (section->sh_entsize, LONG_HEX);
6573
6574 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6575
6576 printf (" %2u %3u %lu\n",
6577 section->sh_link,
6578 section->sh_info,
6579 (unsigned long) section->sh_addralign);
6580 }
6581
6582 if (do_section_details)
6583 {
6584 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6585 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6586 {
6587 /* Minimum section size is 12 bytes for 32-bit compression
6588 header + 12 bytes for compressed data header. */
6589 unsigned char buf[24];
6590
6591 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6592 if (get_data (&buf, filedata, section->sh_offset, 1,
6593 sizeof (buf), _("compression header")))
6594 {
6595 Elf_Internal_Chdr chdr;
6596
6597 (void) get_compression_header (&chdr, buf, sizeof (buf));
6598
6599 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6600 printf (" ZLIB, ");
6601 else
6602 printf (_(" [<unknown>: 0x%x], "),
6603 chdr.ch_type);
6604 print_vma (chdr.ch_size, LONG_HEX);
6605 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6606 }
6607 }
6608 }
6609 }
6610
6611 if (!do_section_details)
6612 {
6613 /* The ordering of the letters shown here matches the ordering of the
6614 corresponding SHF_xxx values, and hence the order in which these
6615 letters will be displayed to the user. */
6616 printf (_("Key to Flags:\n\
6617 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6618 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6619 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6620 if (filedata->file_header.e_machine == EM_X86_64
6621 || filedata->file_header.e_machine == EM_L1OM
6622 || filedata->file_header.e_machine == EM_K1OM)
6623 printf (_("l (large), "));
6624 else if (filedata->file_header.e_machine == EM_ARM)
6625 printf (_("y (purecode), "));
6626 else if (filedata->file_header.e_machine == EM_PPC)
6627 printf (_("v (VLE), "));
6628 printf ("p (processor specific)\n");
6629 }
6630
6631 return TRUE;
6632}
6633
6634static const char *
6635get_group_flags (unsigned int flags)
6636{
6637 static char buff[128];
6638
6639 if (flags == 0)
6640 return "";
6641 else if (flags == GRP_COMDAT)
6642 return "COMDAT ";
6643
6644 snprintf (buff, 14, _("[0x%x: "), flags);
6645
6646 flags &= ~ GRP_COMDAT;
6647 if (flags & GRP_MASKOS)
6648 {
6649 strcat (buff, "<OS specific>");
6650 flags &= ~ GRP_MASKOS;
6651 }
6652
6653 if (flags & GRP_MASKPROC)
6654 {
6655 strcat (buff, "<PROC specific>");
6656 flags &= ~ GRP_MASKPROC;
6657 }
6658
6659 if (flags)
6660 strcat (buff, "<unknown>");
6661
6662 strcat (buff, "]");
6663 return buff;
6664}
6665
6666static bfd_boolean
6667process_section_groups (Filedata * filedata)
6668{
6669 Elf_Internal_Shdr * section;
6670 unsigned int i;
6671 struct group * group;
6672 Elf_Internal_Shdr * symtab_sec;
6673 Elf_Internal_Shdr * strtab_sec;
6674 Elf_Internal_Sym * symtab;
6675 unsigned long num_syms;
6676 char * strtab;
6677 size_t strtab_size;
6678
6679 /* Don't process section groups unless needed. */
6680 if (!do_unwind && !do_section_groups)
6681 return TRUE;
6682
6683 if (filedata->file_header.e_shnum == 0)
6684 {
6685 if (do_section_groups)
6686 printf (_("\nThere are no sections to group in this file.\n"));
6687
6688 return TRUE;
6689 }
6690
6691 if (filedata->section_headers == NULL)
6692 {
6693 error (_("Section headers are not available!\n"));
6694 /* PR 13622: This can happen with a corrupt ELF header. */
6695 return FALSE;
6696 }
6697
6698 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6699 sizeof (struct group *));
6700
6701 if (section_headers_groups == NULL)
6702 {
6703 error (_("Out of memory reading %u section group headers\n"),
6704 filedata->file_header.e_shnum);
6705 return FALSE;
6706 }
6707
6708 /* Scan the sections for the group section. */
6709 group_count = 0;
6710 for (i = 0, section = filedata->section_headers;
6711 i < filedata->file_header.e_shnum;
6712 i++, section++)
6713 if (section->sh_type == SHT_GROUP)
6714 group_count++;
6715
6716 if (group_count == 0)
6717 {
6718 if (do_section_groups)
6719 printf (_("\nThere are no section groups in this file.\n"));
6720
6721 return TRUE;
6722 }
6723
6724 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6725
6726 if (section_groups == NULL)
6727 {
6728 error (_("Out of memory reading %lu groups\n"),
6729 (unsigned long) group_count);
6730 return FALSE;
6731 }
6732
6733 symtab_sec = NULL;
6734 strtab_sec = NULL;
6735 symtab = NULL;
6736 num_syms = 0;
6737 strtab = NULL;
6738 strtab_size = 0;
6739 for (i = 0, section = filedata->section_headers, group = section_groups;
6740 i < filedata->file_header.e_shnum;
6741 i++, section++)
6742 {
6743 if (section->sh_type == SHT_GROUP)
6744 {
6745 const char * name = printable_section_name (filedata, section);
6746 const char * group_name;
6747 unsigned char * start;
6748 unsigned char * indices;
6749 unsigned int entry, j, size;
6750 Elf_Internal_Shdr * sec;
6751 Elf_Internal_Sym * sym;
6752
6753 /* Get the symbol table. */
6754 if (section->sh_link >= filedata->file_header.e_shnum
6755 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6756 != SHT_SYMTAB))
6757 {
6758 error (_("Bad sh_link in group section `%s'\n"), name);
6759 continue;
6760 }
6761
6762 if (symtab_sec != sec)
6763 {
6764 symtab_sec = sec;
6765 if (symtab)
6766 free (symtab);
6767 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6768 }
6769
6770 if (symtab == NULL)
6771 {
6772 error (_("Corrupt header in group section `%s'\n"), name);
6773 continue;
6774 }
6775
6776 if (section->sh_info >= num_syms)
6777 {
6778 error (_("Bad sh_info in group section `%s'\n"), name);
6779 continue;
6780 }
6781
6782 sym = symtab + section->sh_info;
6783
6784 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6785 {
6786 if (sym->st_shndx == 0
6787 || sym->st_shndx >= filedata->file_header.e_shnum)
6788 {
6789 error (_("Bad sh_info in group section `%s'\n"), name);
6790 continue;
6791 }
6792
6793 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6794 strtab_sec = NULL;
6795 if (strtab)
6796 free (strtab);
6797 strtab = NULL;
6798 strtab_size = 0;
6799 }
6800 else
6801 {
6802 /* Get the string table. */
6803 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6804 {
6805 strtab_sec = NULL;
6806 if (strtab)
6807 free (strtab);
6808 strtab = NULL;
6809 strtab_size = 0;
6810 }
6811 else if (strtab_sec
6812 != (sec = filedata->section_headers + symtab_sec->sh_link))
6813 {
6814 strtab_sec = sec;
6815 if (strtab)
6816 free (strtab);
6817
6818 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6819 1, strtab_sec->sh_size,
6820 _("string table"));
6821 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6822 }
6823 group_name = sym->st_name < strtab_size
6824 ? strtab + sym->st_name : _("<corrupt>");
6825 }
6826
6827 /* PR 17531: file: loop. */
6828 if (section->sh_entsize > section->sh_size)
6829 {
6830 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6831 printable_section_name (filedata, section),
6832 (unsigned long) section->sh_entsize,
6833 (unsigned long) section->sh_size);
6834 break;
6835 }
6836
6837 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6838 1, section->sh_size,
6839 _("section data"));
6840 if (start == NULL)
6841 continue;
6842
6843 indices = start;
6844 size = (section->sh_size / section->sh_entsize) - 1;
6845 entry = byte_get (indices, 4);
6846 indices += 4;
6847
6848 if (do_section_groups)
6849 {
6850 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6851 get_group_flags (entry), i, name, group_name, size);
6852
6853 printf (_(" [Index] Name\n"));
6854 }
6855
6856 group->group_index = i;
6857
6858 for (j = 0; j < size; j++)
6859 {
6860 struct group_list * g;
6861
6862 entry = byte_get (indices, 4);
6863 indices += 4;
6864
6865 if (entry >= filedata->file_header.e_shnum)
6866 {
6867 static unsigned num_group_errors = 0;
6868
6869 if (num_group_errors ++ < 10)
6870 {
6871 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6872 entry, i, filedata->file_header.e_shnum - 1);
6873 if (num_group_errors == 10)
6874 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6875 }
6876 continue;
6877 }
6878
6879 if (section_headers_groups [entry] != NULL)
6880 {
6881 if (entry)
6882 {
6883 static unsigned num_errs = 0;
6884
6885 if (num_errs ++ < 10)
6886 {
6887 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6888 entry, i,
6889 section_headers_groups [entry]->group_index);
6890 if (num_errs == 10)
6891 warn (_("Further error messages about already contained group sections suppressed\n"));
6892 }
6893 continue;
6894 }
6895 else
6896 {
6897 /* Intel C/C++ compiler may put section 0 in a
6898 section group. We just warn it the first time
6899 and ignore it afterwards. */
6900 static bfd_boolean warned = FALSE;
6901 if (!warned)
6902 {
6903 error (_("section 0 in group section [%5u]\n"),
6904 section_headers_groups [entry]->group_index);
6905 warned = TRUE;
6906 }
6907 }
6908 }
6909
6910 section_headers_groups [entry] = group;
6911
6912 if (do_section_groups)
6913 {
6914 sec = filedata->section_headers + entry;
6915 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6916 }
6917
6918 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6919 g->section_index = entry;
6920 g->next = group->root;
6921 group->root = g;
6922 }
6923
6924 if (start)
6925 free (start);
6926
6927 group++;
6928 }
6929 }
6930
6931 if (symtab)
6932 free (symtab);
6933 if (strtab)
6934 free (strtab);
6935 return TRUE;
6936}
6937
6938/* Data used to display dynamic fixups. */
6939
6940struct ia64_vms_dynfixup
6941{
6942 bfd_vma needed_ident; /* Library ident number. */
6943 bfd_vma needed; /* Index in the dstrtab of the library name. */
6944 bfd_vma fixup_needed; /* Index of the library. */
6945 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6946 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6947};
6948
6949/* Data used to display dynamic relocations. */
6950
6951struct ia64_vms_dynimgrela
6952{
6953 bfd_vma img_rela_cnt; /* Number of relocations. */
6954 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6955};
6956
6957/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6958 library). */
6959
6960static bfd_boolean
6961dump_ia64_vms_dynamic_fixups (Filedata * filedata,
6962 struct ia64_vms_dynfixup * fixup,
6963 const char * strtab,
6964 unsigned int strtab_sz)
6965{
6966 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6967 long i;
6968 const char * lib_name;
6969
6970 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6971 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6972 _("dynamic section image fixups"));
6973 if (!imfs)
6974 return FALSE;
6975
6976 if (fixup->needed < strtab_sz)
6977 lib_name = strtab + fixup->needed;
6978 else
6979 {
6980 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6981 (unsigned long) fixup->needed);
6982 lib_name = "???";
6983 }
6984 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6985 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6986 printf
6987 (_("Seg Offset Type SymVec DataType\n"));
6988
6989 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6990 {
6991 unsigned int type;
6992 const char *rtype;
6993
6994 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6995 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6996 type = BYTE_GET (imfs [i].type);
6997 rtype = elf_ia64_reloc_type (type);
6998 if (rtype == NULL)
6999 printf (" 0x%08x ", type);
7000 else
7001 printf (" %-32s ", rtype);
7002 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7003 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7004 }
7005
7006 free (imfs);
7007 return TRUE;
7008}
7009
7010/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7011
7012static bfd_boolean
7013dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7014{
7015 Elf64_External_VMS_IMAGE_RELA *imrs;
7016 long i;
7017
7018 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7019 1, imgrela->img_rela_cnt * sizeof (*imrs),
7020 _("dynamic section image relocations"));
7021 if (!imrs)
7022 return FALSE;
7023
7024 printf (_("\nImage relocs\n"));
7025 printf
7026 (_("Seg Offset Type Addend Seg Sym Off\n"));
7027
7028 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7029 {
7030 unsigned int type;
7031 const char *rtype;
7032
7033 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7034 printf ("%08" BFD_VMA_FMT "x ",
7035 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7036 type = BYTE_GET (imrs [i].type);
7037 rtype = elf_ia64_reloc_type (type);
7038 if (rtype == NULL)
7039 printf ("0x%08x ", type);
7040 else
7041 printf ("%-31s ", rtype);
7042 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7043 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7044 printf ("%08" BFD_VMA_FMT "x\n",
7045 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7046 }
7047
7048 free (imrs);
7049 return TRUE;
7050}
7051
7052/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7053
7054static bfd_boolean
7055process_ia64_vms_dynamic_relocs (Filedata * filedata)
7056{
7057 struct ia64_vms_dynfixup fixup;
7058 struct ia64_vms_dynimgrela imgrela;
7059 Elf_Internal_Dyn *entry;
7060 bfd_vma strtab_off = 0;
7061 bfd_vma strtab_sz = 0;
7062 char *strtab = NULL;
7063 bfd_boolean res = TRUE;
7064
7065 memset (&fixup, 0, sizeof (fixup));
7066 memset (&imgrela, 0, sizeof (imgrela));
7067
7068 /* Note: the order of the entries is specified by the OpenVMS specs. */
7069 for (entry = dynamic_section;
7070 entry < dynamic_section + dynamic_nent;
7071 entry++)
7072 {
7073 switch (entry->d_tag)
7074 {
7075 case DT_IA_64_VMS_STRTAB_OFFSET:
7076 strtab_off = entry->d_un.d_val;
7077 break;
7078 case DT_STRSZ:
7079 strtab_sz = entry->d_un.d_val;
7080 if (strtab == NULL)
7081 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7082 1, strtab_sz, _("dynamic string section"));
7083 break;
7084
7085 case DT_IA_64_VMS_NEEDED_IDENT:
7086 fixup.needed_ident = entry->d_un.d_val;
7087 break;
7088 case DT_NEEDED:
7089 fixup.needed = entry->d_un.d_val;
7090 break;
7091 case DT_IA_64_VMS_FIXUP_NEEDED:
7092 fixup.fixup_needed = entry->d_un.d_val;
7093 break;
7094 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7095 fixup.fixup_rela_cnt = entry->d_un.d_val;
7096 break;
7097 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7098 fixup.fixup_rela_off = entry->d_un.d_val;
7099 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7100 res = FALSE;
7101 break;
7102 case DT_IA_64_VMS_IMG_RELA_CNT:
7103 imgrela.img_rela_cnt = entry->d_un.d_val;
7104 break;
7105 case DT_IA_64_VMS_IMG_RELA_OFF:
7106 imgrela.img_rela_off = entry->d_un.d_val;
7107 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7108 res = FALSE;
7109 break;
7110
7111 default:
7112 break;
7113 }
7114 }
7115
7116 if (strtab != NULL)
7117 free (strtab);
7118
7119 return res;
7120}
7121
7122static struct
7123{
7124 const char * name;
7125 int reloc;
7126 int size;
7127 int rela;
7128}
7129 dynamic_relocations [] =
7130{
7131 { "REL", DT_REL, DT_RELSZ, FALSE },
7132 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7133 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7134};
7135
7136/* Process the reloc section. */
7137
7138static bfd_boolean
7139process_relocs (Filedata * filedata)
7140{
7141 unsigned long rel_size;
7142 unsigned long rel_offset;
7143
7144 if (!do_reloc)
7145 return TRUE;
7146
7147 if (do_using_dynamic)
7148 {
7149 int is_rela;
7150 const char * name;
7151 bfd_boolean has_dynamic_reloc;
7152 unsigned int i;
7153
7154 has_dynamic_reloc = FALSE;
7155
7156 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7157 {
7158 is_rela = dynamic_relocations [i].rela;
7159 name = dynamic_relocations [i].name;
7160 rel_size = dynamic_info [dynamic_relocations [i].size];
7161 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7162
7163 if (rel_size)
7164 has_dynamic_reloc = TRUE;
7165
7166 if (is_rela == UNKNOWN)
7167 {
7168 if (dynamic_relocations [i].reloc == DT_JMPREL)
7169 switch (dynamic_info[DT_PLTREL])
7170 {
7171 case DT_REL:
7172 is_rela = FALSE;
7173 break;
7174 case DT_RELA:
7175 is_rela = TRUE;
7176 break;
7177 }
7178 }
7179
7180 if (rel_size)
7181 {
7182 printf
7183 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7184 name, rel_offset, rel_size);
7185
7186 dump_relocations (filedata,
7187 offset_from_vma (filedata, rel_offset, rel_size),
7188 rel_size,
7189 dynamic_symbols, num_dynamic_syms,
7190 dynamic_strings, dynamic_strings_length,
7191 is_rela, TRUE /* is_dynamic */);
7192 }
7193 }
7194
7195 if (is_ia64_vms (filedata))
7196 if (process_ia64_vms_dynamic_relocs (filedata))
7197 has_dynamic_reloc = TRUE;
7198
7199 if (! has_dynamic_reloc)
7200 printf (_("\nThere are no dynamic relocations in this file.\n"));
7201 }
7202 else
7203 {
7204 Elf_Internal_Shdr * section;
7205 unsigned long i;
7206 bfd_boolean found = FALSE;
7207
7208 for (i = 0, section = filedata->section_headers;
7209 i < filedata->file_header.e_shnum;
7210 i++, section++)
7211 {
7212 if ( section->sh_type != SHT_RELA
7213 && section->sh_type != SHT_REL)
7214 continue;
7215
7216 rel_offset = section->sh_offset;
7217 rel_size = section->sh_size;
7218
7219 if (rel_size)
7220 {
7221 Elf_Internal_Shdr * strsec;
7222 int is_rela;
7223 unsigned long num_rela;
7224
7225 printf (_("\nRelocation section "));
7226
7227 if (filedata->string_table == NULL)
7228 printf ("%d", section->sh_name);
7229 else
7230 printf ("'%s'", printable_section_name (filedata, section));
7231
7232 num_rela = rel_size / section->sh_entsize;
7233 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7234 " at offset 0x%lx contains %lu entries:\n",
7235 num_rela),
7236 rel_offset, num_rela);
7237
7238 is_rela = section->sh_type == SHT_RELA;
7239
7240 if (section->sh_link != 0
7241 && section->sh_link < filedata->file_header.e_shnum)
7242 {
7243 Elf_Internal_Shdr * symsec;
7244 Elf_Internal_Sym * symtab;
7245 unsigned long nsyms;
7246 unsigned long strtablen = 0;
7247 char * strtab = NULL;
7248
7249 symsec = filedata->section_headers + section->sh_link;
7250 if (symsec->sh_type != SHT_SYMTAB
7251 && symsec->sh_type != SHT_DYNSYM)
7252 continue;
7253
7254 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7255
7256 if (symtab == NULL)
7257 continue;
7258
7259 if (symsec->sh_link != 0
7260 && symsec->sh_link < filedata->file_header.e_shnum)
7261 {
7262 strsec = filedata->section_headers + symsec->sh_link;
7263
7264 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7265 1, strsec->sh_size,
7266 _("string table"));
7267 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7268 }
7269
7270 dump_relocations (filedata, rel_offset, rel_size,
7271 symtab, nsyms, strtab, strtablen,
7272 is_rela,
7273 symsec->sh_type == SHT_DYNSYM);
7274 if (strtab)
7275 free (strtab);
7276 free (symtab);
7277 }
7278 else
7279 dump_relocations (filedata, rel_offset, rel_size,
7280 NULL, 0, NULL, 0, is_rela,
7281 FALSE /* is_dynamic */);
7282
7283 found = TRUE;
7284 }
7285 }
7286
7287 if (! found)
7288 {
7289 /* Users sometimes forget the -D option, so try to be helpful. */
7290 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7291 {
7292 if (dynamic_info [dynamic_relocations [i].size])
7293 {
7294 printf (_("\nThere are no static relocations in this file."));
7295 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7296
7297 break;
7298 }
7299 }
7300 if (i == ARRAY_SIZE (dynamic_relocations))
7301 printf (_("\nThere are no relocations in this file.\n"));
7302 }
7303 }
7304
7305 return TRUE;
7306}
7307
7308/* An absolute address consists of a section and an offset. If the
7309 section is NULL, the offset itself is the address, otherwise, the
7310 address equals to LOAD_ADDRESS(section) + offset. */
7311
7312struct absaddr
7313{
7314 unsigned short section;
7315 bfd_vma offset;
7316};
7317
7318#define ABSADDR(a) \
7319 ((a).section \
7320 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7321 : (a).offset)
7322
7323/* Find the nearest symbol at or below ADDR. Returns the symbol
7324 name, if found, and the offset from the symbol to ADDR. */
7325
7326static void
7327find_symbol_for_address (Filedata * filedata,
7328 Elf_Internal_Sym * symtab,
7329 unsigned long nsyms,
7330 const char * strtab,
7331 unsigned long strtab_size,
7332 struct absaddr addr,
7333 const char ** symname,
7334 bfd_vma * offset)
7335{
7336 bfd_vma dist = 0x100000;
7337 Elf_Internal_Sym * sym;
7338 Elf_Internal_Sym * beg;
7339 Elf_Internal_Sym * end;
7340 Elf_Internal_Sym * best = NULL;
7341
7342 REMOVE_ARCH_BITS (addr.offset);
7343 beg = symtab;
7344 end = symtab + nsyms;
7345
7346 while (beg < end)
7347 {
7348 bfd_vma value;
7349
7350 sym = beg + (end - beg) / 2;
7351
7352 value = sym->st_value;
7353 REMOVE_ARCH_BITS (value);
7354
7355 if (sym->st_name != 0
7356 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7357 && addr.offset >= value
7358 && addr.offset - value < dist)
7359 {
7360 best = sym;
7361 dist = addr.offset - value;
7362 if (!dist)
7363 break;
7364 }
7365
7366 if (addr.offset < value)
7367 end = sym;
7368 else
7369 beg = sym + 1;
7370 }
7371
7372 if (best)
7373 {
7374 *symname = (best->st_name >= strtab_size
7375 ? _("<corrupt>") : strtab + best->st_name);
7376 *offset = dist;
7377 return;
7378 }
7379
7380 *symname = NULL;
7381 *offset = addr.offset;
7382}
7383
7384static /* signed */ int
7385symcmp (const void *p, const void *q)
7386{
7387 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7388 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7389
7390 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7391}
7392
7393/* Process the unwind section. */
7394
7395#include "unwind-ia64.h"
7396
7397struct ia64_unw_table_entry
7398{
7399 struct absaddr start;
7400 struct absaddr end;
7401 struct absaddr info;
7402};
7403
7404struct ia64_unw_aux_info
7405{
7406 struct ia64_unw_table_entry * table; /* Unwind table. */
7407 unsigned long table_len; /* Length of unwind table. */
7408 unsigned char * info; /* Unwind info. */
7409 unsigned long info_size; /* Size of unwind info. */
7410 bfd_vma info_addr; /* Starting address of unwind info. */
7411 bfd_vma seg_base; /* Starting address of segment. */
7412 Elf_Internal_Sym * symtab; /* The symbol table. */
7413 unsigned long nsyms; /* Number of symbols. */
7414 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7415 unsigned long nfuns; /* Number of entries in funtab. */
7416 char * strtab; /* The string table. */
7417 unsigned long strtab_size; /* Size of string table. */
7418};
7419
7420static bfd_boolean
7421dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7422{
7423 struct ia64_unw_table_entry * tp;
7424 unsigned long j, nfuns;
7425 int in_body;
7426 bfd_boolean res = TRUE;
7427
7428 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7429 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7430 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7431 aux->funtab[nfuns++] = aux->symtab[j];
7432 aux->nfuns = nfuns;
7433 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7434
7435 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7436 {
7437 bfd_vma stamp;
7438 bfd_vma offset;
7439 const unsigned char * dp;
7440 const unsigned char * head;
7441 const unsigned char * end;
7442 const char * procname;
7443
7444 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7445 aux->strtab_size, tp->start, &procname, &offset);
7446
7447 fputs ("\n<", stdout);
7448
7449 if (procname)
7450 {
7451 fputs (procname, stdout);
7452
7453 if (offset)
7454 printf ("+%lx", (unsigned long) offset);
7455 }
7456
7457 fputs (">: [", stdout);
7458 print_vma (tp->start.offset, PREFIX_HEX);
7459 fputc ('-', stdout);
7460 print_vma (tp->end.offset, PREFIX_HEX);
7461 printf ("], info at +0x%lx\n",
7462 (unsigned long) (tp->info.offset - aux->seg_base));
7463
7464 /* PR 17531: file: 86232b32. */
7465 if (aux->info == NULL)
7466 continue;
7467
7468 /* PR 17531: file: 0997b4d1. */
7469 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7470 {
7471 warn (_("Invalid offset %lx in table entry %ld\n"),
7472 (long) tp->info.offset, (long) (tp - aux->table));
7473 res = FALSE;
7474 continue;
7475 }
7476
7477 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7478 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7479
7480 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7481 (unsigned) UNW_VER (stamp),
7482 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7483 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7484 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7485 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7486
7487 if (UNW_VER (stamp) != 1)
7488 {
7489 printf (_("\tUnknown version.\n"));
7490 continue;
7491 }
7492
7493 in_body = 0;
7494 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7495 /* PR 17531: file: 16ceda89. */
7496 if (end > aux->info + aux->info_size)
7497 end = aux->info + aux->info_size;
7498 for (dp = head + 8; dp < end;)
7499 dp = unw_decode (dp, in_body, & in_body, end);
7500 }
7501
7502 free (aux->funtab);
7503
7504 return res;
7505}
7506
7507static bfd_boolean
7508slurp_ia64_unwind_table (Filedata * filedata,
7509 struct ia64_unw_aux_info * aux,
7510 Elf_Internal_Shdr * sec)
7511{
7512 unsigned long size, nrelas, i;
7513 Elf_Internal_Phdr * seg;
7514 struct ia64_unw_table_entry * tep;
7515 Elf_Internal_Shdr * relsec;
7516 Elf_Internal_Rela * rela;
7517 Elf_Internal_Rela * rp;
7518 unsigned char * table;
7519 unsigned char * tp;
7520 Elf_Internal_Sym * sym;
7521 const char * relname;
7522
7523 aux->table_len = 0;
7524
7525 /* First, find the starting address of the segment that includes
7526 this section: */
7527
7528 if (filedata->file_header.e_phnum)
7529 {
7530 if (! get_program_headers (filedata))
7531 return FALSE;
7532
7533 for (seg = filedata->program_headers;
7534 seg < filedata->program_headers + filedata->file_header.e_phnum;
7535 ++seg)
7536 {
7537 if (seg->p_type != PT_LOAD)
7538 continue;
7539
7540 if (sec->sh_addr >= seg->p_vaddr
7541 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7542 {
7543 aux->seg_base = seg->p_vaddr;
7544 break;
7545 }
7546 }
7547 }
7548
7549 /* Second, build the unwind table from the contents of the unwind section: */
7550 size = sec->sh_size;
7551 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7552 _("unwind table"));
7553 if (!table)
7554 return FALSE;
7555
7556 aux->table_len = size / (3 * eh_addr_size);
7557 aux->table = (struct ia64_unw_table_entry *)
7558 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7559 tep = aux->table;
7560
7561 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7562 {
7563 tep->start.section = SHN_UNDEF;
7564 tep->end.section = SHN_UNDEF;
7565 tep->info.section = SHN_UNDEF;
7566 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7567 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7568 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7569 tep->start.offset += aux->seg_base;
7570 tep->end.offset += aux->seg_base;
7571 tep->info.offset += aux->seg_base;
7572 }
7573 free (table);
7574
7575 /* Third, apply any relocations to the unwind table: */
7576 for (relsec = filedata->section_headers;
7577 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7578 ++relsec)
7579 {
7580 if (relsec->sh_type != SHT_RELA
7581 || relsec->sh_info >= filedata->file_header.e_shnum
7582 || filedata->section_headers + relsec->sh_info != sec)
7583 continue;
7584
7585 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7586 & rela, & nrelas))
7587 {
7588 free (aux->table);
7589 aux->table = NULL;
7590 aux->table_len = 0;
7591 return FALSE;
7592 }
7593
7594 for (rp = rela; rp < rela + nrelas; ++rp)
7595 {
7596 relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7597 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7598
7599 /* PR 17531: file: 9fa67536. */
7600 if (relname == NULL)
7601 {
7602 warn (_("Skipping unknown relocation type: %u\n"),
7603 get_reloc_type (filedata, rp->r_info));
7604 continue;
7605 }
7606
7607 if (! const_strneq (relname, "R_IA64_SEGREL"))
7608 {
7609 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7610 continue;
7611 }
7612
7613 i = rp->r_offset / (3 * eh_addr_size);
7614
7615 /* PR 17531: file: 5bc8d9bf. */
7616 if (i >= aux->table_len)
7617 {
7618 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7619 continue;
7620 }
7621
7622 switch (rp->r_offset / eh_addr_size % 3)
7623 {
7624 case 0:
7625 aux->table[i].start.section = sym->st_shndx;
7626 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7627 break;
7628 case 1:
7629 aux->table[i].end.section = sym->st_shndx;
7630 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7631 break;
7632 case 2:
7633 aux->table[i].info.section = sym->st_shndx;
7634 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7635 break;
7636 default:
7637 break;
7638 }
7639 }
7640
7641 free (rela);
7642 }
7643
7644 return TRUE;
7645}
7646
7647static bfd_boolean
7648ia64_process_unwind (Filedata * filedata)
7649{
7650 Elf_Internal_Shdr * sec;
7651 Elf_Internal_Shdr * unwsec = NULL;
7652 Elf_Internal_Shdr * strsec;
7653 unsigned long i, unwcount = 0, unwstart = 0;
7654 struct ia64_unw_aux_info aux;
7655 bfd_boolean res = TRUE;
7656
7657 memset (& aux, 0, sizeof (aux));
7658
7659 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7660 {
7661 if (sec->sh_type == SHT_SYMTAB
7662 && sec->sh_link < filedata->file_header.e_shnum)
7663 {
7664 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7665
7666 strsec = filedata->section_headers + sec->sh_link;
7667 if (aux.strtab != NULL)
7668 {
7669 error (_("Multiple auxillary string tables encountered\n"));
7670 free (aux.strtab);
7671 res = FALSE;
7672 }
7673 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7674 1, strsec->sh_size,
7675 _("string table"));
7676 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7677 }
7678 else if (sec->sh_type == SHT_IA_64_UNWIND)
7679 unwcount++;
7680 }
7681
7682 if (!unwcount)
7683 printf (_("\nThere are no unwind sections in this file.\n"));
7684
7685 while (unwcount-- > 0)
7686 {
7687 char * suffix;
7688 size_t len, len2;
7689
7690 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7691 i < filedata->file_header.e_shnum; ++i, ++sec)
7692 if (sec->sh_type == SHT_IA_64_UNWIND)
7693 {
7694 unwsec = sec;
7695 break;
7696 }
7697 /* We have already counted the number of SHT_IA64_UNWIND
7698 sections so the loop above should never fail. */
7699 assert (unwsec != NULL);
7700
7701 unwstart = i + 1;
7702 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7703
7704 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7705 {
7706 /* We need to find which section group it is in. */
7707 struct group_list * g;
7708
7709 if (section_headers_groups == NULL
7710 || section_headers_groups [i] == NULL)
7711 i = filedata->file_header.e_shnum;
7712 else
7713 {
7714 g = section_headers_groups [i]->root;
7715
7716 for (; g != NULL; g = g->next)
7717 {
7718 sec = filedata->section_headers + g->section_index;
7719
7720 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7721 break;
7722 }
7723
7724 if (g == NULL)
7725 i = filedata->file_header.e_shnum;
7726 }
7727 }
7728 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7729 {
7730 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7731 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7732 suffix = SECTION_NAME (unwsec) + len;
7733 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7734 ++i, ++sec)
7735 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7736 && streq (SECTION_NAME (sec) + len2, suffix))
7737 break;
7738 }
7739 else
7740 {
7741 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7742 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7743 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7744 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7745 suffix = "";
7746 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7747 suffix = SECTION_NAME (unwsec) + len;
7748 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7749 ++i, ++sec)
7750 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7751 && streq (SECTION_NAME (sec) + len2, suffix))
7752 break;
7753 }
7754
7755 if (i == filedata->file_header.e_shnum)
7756 {
7757 printf (_("\nCould not find unwind info section for "));
7758
7759 if (filedata->string_table == NULL)
7760 printf ("%d", unwsec->sh_name);
7761 else
7762 printf ("'%s'", printable_section_name (filedata, unwsec));
7763 }
7764 else
7765 {
7766 aux.info_addr = sec->sh_addr;
7767 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7768 sec->sh_size,
7769 _("unwind info"));
7770 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7771
7772 printf (_("\nUnwind section "));
7773
7774 if (filedata->string_table == NULL)
7775 printf ("%d", unwsec->sh_name);
7776 else
7777 printf ("'%s'", printable_section_name (filedata, unwsec));
7778
7779 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7780 (unsigned long) unwsec->sh_offset,
7781 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7782
7783 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7784 && aux.table_len > 0)
7785 dump_ia64_unwind (filedata, & aux);
7786
7787 if (aux.table)
7788 free ((char *) aux.table);
7789 if (aux.info)
7790 free ((char *) aux.info);
7791 aux.table = NULL;
7792 aux.info = NULL;
7793 }
7794 }
7795
7796 if (aux.symtab)
7797 free (aux.symtab);
7798 if (aux.strtab)
7799 free ((char *) aux.strtab);
7800
7801 return res;
7802}
7803
7804struct hppa_unw_table_entry
7805{
7806 struct absaddr start;
7807 struct absaddr end;
7808 unsigned int Cannot_unwind:1; /* 0 */
7809 unsigned int Millicode:1; /* 1 */
7810 unsigned int Millicode_save_sr0:1; /* 2 */
7811 unsigned int Region_description:2; /* 3..4 */
7812 unsigned int reserved1:1; /* 5 */
7813 unsigned int Entry_SR:1; /* 6 */
7814 unsigned int Entry_FR:4; /* Number saved 7..10 */
7815 unsigned int Entry_GR:5; /* Number saved 11..15 */
7816 unsigned int Args_stored:1; /* 16 */
7817 unsigned int Variable_Frame:1; /* 17 */
7818 unsigned int Separate_Package_Body:1; /* 18 */
7819 unsigned int Frame_Extension_Millicode:1; /* 19 */
7820 unsigned int Stack_Overflow_Check:1; /* 20 */
7821 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7822 unsigned int Ada_Region:1; /* 22 */
7823 unsigned int cxx_info:1; /* 23 */
7824 unsigned int cxx_try_catch:1; /* 24 */
7825 unsigned int sched_entry_seq:1; /* 25 */
7826 unsigned int reserved2:1; /* 26 */
7827 unsigned int Save_SP:1; /* 27 */
7828 unsigned int Save_RP:1; /* 28 */
7829 unsigned int Save_MRP_in_frame:1; /* 29 */
7830 unsigned int extn_ptr_defined:1; /* 30 */
7831 unsigned int Cleanup_defined:1; /* 31 */
7832
7833 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7834 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7835 unsigned int Large_frame:1; /* 2 */
7836 unsigned int Pseudo_SP_Set:1; /* 3 */
7837 unsigned int reserved4:1; /* 4 */
7838 unsigned int Total_frame_size:27; /* 5..31 */
7839};
7840
7841struct hppa_unw_aux_info
7842{
7843 struct hppa_unw_table_entry * table; /* Unwind table. */
7844 unsigned long table_len; /* Length of unwind table. */
7845 bfd_vma seg_base; /* Starting address of segment. */
7846 Elf_Internal_Sym * symtab; /* The symbol table. */
7847 unsigned long nsyms; /* Number of symbols. */
7848 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7849 unsigned long nfuns; /* Number of entries in funtab. */
7850 char * strtab; /* The string table. */
7851 unsigned long strtab_size; /* Size of string table. */
7852};
7853
7854static bfd_boolean
7855dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7856{
7857 struct hppa_unw_table_entry * tp;
7858 unsigned long j, nfuns;
7859 bfd_boolean res = TRUE;
7860
7861 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7862 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7863 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7864 aux->funtab[nfuns++] = aux->symtab[j];
7865 aux->nfuns = nfuns;
7866 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7867
7868 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7869 {
7870 bfd_vma offset;
7871 const char * procname;
7872
7873 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7874 aux->strtab_size, tp->start, &procname,
7875 &offset);
7876
7877 fputs ("\n<", stdout);
7878
7879 if (procname)
7880 {
7881 fputs (procname, stdout);
7882
7883 if (offset)
7884 printf ("+%lx", (unsigned long) offset);
7885 }
7886
7887 fputs (">: [", stdout);
7888 print_vma (tp->start.offset, PREFIX_HEX);
7889 fputc ('-', stdout);
7890 print_vma (tp->end.offset, PREFIX_HEX);
7891 printf ("]\n\t");
7892
7893#define PF(_m) if (tp->_m) printf (#_m " ");
7894#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7895 PF(Cannot_unwind);
7896 PF(Millicode);
7897 PF(Millicode_save_sr0);
7898 /* PV(Region_description); */
7899 PF(Entry_SR);
7900 PV(Entry_FR);
7901 PV(Entry_GR);
7902 PF(Args_stored);
7903 PF(Variable_Frame);
7904 PF(Separate_Package_Body);
7905 PF(Frame_Extension_Millicode);
7906 PF(Stack_Overflow_Check);
7907 PF(Two_Instruction_SP_Increment);
7908 PF(Ada_Region);
7909 PF(cxx_info);
7910 PF(cxx_try_catch);
7911 PF(sched_entry_seq);
7912 PF(Save_SP);
7913 PF(Save_RP);
7914 PF(Save_MRP_in_frame);
7915 PF(extn_ptr_defined);
7916 PF(Cleanup_defined);
7917 PF(MPE_XL_interrupt_marker);
7918 PF(HP_UX_interrupt_marker);
7919 PF(Large_frame);
7920 PF(Pseudo_SP_Set);
7921 PV(Total_frame_size);
7922#undef PF
7923#undef PV
7924 }
7925
7926 printf ("\n");
7927
7928 free (aux->funtab);
7929
7930 return res;
7931}
7932
7933static bfd_boolean
7934slurp_hppa_unwind_table (Filedata * filedata,
7935 struct hppa_unw_aux_info * aux,
7936 Elf_Internal_Shdr * sec)
7937{
7938 unsigned long size, unw_ent_size, nentries, nrelas, i;
7939 Elf_Internal_Phdr * seg;
7940 struct hppa_unw_table_entry * tep;
7941 Elf_Internal_Shdr * relsec;
7942 Elf_Internal_Rela * rela;
7943 Elf_Internal_Rela * rp;
7944 unsigned char * table;
7945 unsigned char * tp;
7946 Elf_Internal_Sym * sym;
7947 const char * relname;
7948
7949 /* First, find the starting address of the segment that includes
7950 this section. */
7951 if (filedata->file_header.e_phnum)
7952 {
7953 if (! get_program_headers (filedata))
7954 return FALSE;
7955
7956 for (seg = filedata->program_headers;
7957 seg < filedata->program_headers + filedata->file_header.e_phnum;
7958 ++seg)
7959 {
7960 if (seg->p_type != PT_LOAD)
7961 continue;
7962
7963 if (sec->sh_addr >= seg->p_vaddr
7964 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7965 {
7966 aux->seg_base = seg->p_vaddr;
7967 break;
7968 }
7969 }
7970 }
7971
7972 /* Second, build the unwind table from the contents of the unwind
7973 section. */
7974 size = sec->sh_size;
7975 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7976 _("unwind table"));
7977 if (!table)
7978 return FALSE;
7979
7980 unw_ent_size = 16;
7981 nentries = size / unw_ent_size;
7982 size = unw_ent_size * nentries;
7983
7984 tep = aux->table = (struct hppa_unw_table_entry *)
7985 xcmalloc (nentries, sizeof (aux->table[0]));
7986
7987 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7988 {
7989 unsigned int tmp1, tmp2;
7990
7991 tep->start.section = SHN_UNDEF;
7992 tep->end.section = SHN_UNDEF;
7993
7994 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7995 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7996 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7997 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7998
7999 tep->start.offset += aux->seg_base;
8000 tep->end.offset += aux->seg_base;
8001
8002 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8003 tep->Millicode = (tmp1 >> 30) & 0x1;
8004 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8005 tep->Region_description = (tmp1 >> 27) & 0x3;
8006 tep->reserved1 = (tmp1 >> 26) & 0x1;
8007 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8008 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8009 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8010 tep->Args_stored = (tmp1 >> 15) & 0x1;
8011 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8012 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8013 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8014 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8015 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8016 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8017 tep->cxx_info = (tmp1 >> 8) & 0x1;
8018 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8019 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8020 tep->reserved2 = (tmp1 >> 5) & 0x1;
8021 tep->Save_SP = (tmp1 >> 4) & 0x1;
8022 tep->Save_RP = (tmp1 >> 3) & 0x1;
8023 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8024 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8025 tep->Cleanup_defined = tmp1 & 0x1;
8026
8027 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8028 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8029 tep->Large_frame = (tmp2 >> 29) & 0x1;
8030 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8031 tep->reserved4 = (tmp2 >> 27) & 0x1;
8032 tep->Total_frame_size = tmp2 & 0x7ffffff;
8033 }
8034 free (table);
8035
8036 /* Third, apply any relocations to the unwind table. */
8037 for (relsec = filedata->section_headers;
8038 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8039 ++relsec)
8040 {
8041 if (relsec->sh_type != SHT_RELA
8042 || relsec->sh_info >= filedata->file_header.e_shnum
8043 || filedata->section_headers + relsec->sh_info != sec)
8044 continue;
8045
8046 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8047 & rela, & nrelas))
8048 return FALSE;
8049
8050 for (rp = rela; rp < rela + nrelas; ++rp)
8051 {
8052 relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8053 sym = aux->symtab + get_reloc_symindex (rp->r_info);
8054
8055 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8056 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8057 {
8058 warn (_("Skipping unexpected relocation type %s\n"), relname);
8059 continue;
8060 }
8061
8062 i = rp->r_offset / unw_ent_size;
8063
8064 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8065 {
8066 case 0:
8067 aux->table[i].start.section = sym->st_shndx;
8068 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8069 break;
8070 case 1:
8071 aux->table[i].end.section = sym->st_shndx;
8072 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8073 break;
8074 default:
8075 break;
8076 }
8077 }
8078
8079 free (rela);
8080 }
8081
8082 aux->table_len = nentries;
8083
8084 return TRUE;
8085}
8086
8087static bfd_boolean
8088hppa_process_unwind (Filedata * filedata)
8089{
8090 struct hppa_unw_aux_info aux;
8091 Elf_Internal_Shdr * unwsec = NULL;
8092 Elf_Internal_Shdr * strsec;
8093 Elf_Internal_Shdr * sec;
8094 unsigned long i;
8095 bfd_boolean res = TRUE;
8096
8097 if (filedata->string_table == NULL)
8098 return FALSE;
8099
8100 memset (& aux, 0, sizeof (aux));
8101
8102 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8103 {
8104 if (sec->sh_type == SHT_SYMTAB
8105 && sec->sh_link < filedata->file_header.e_shnum)
8106 {
8107 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8108
8109 strsec = filedata->section_headers + sec->sh_link;
8110 if (aux.strtab != NULL)
8111 {
8112 error (_("Multiple auxillary string tables encountered\n"));
8113 free (aux.strtab);
8114 res = FALSE;
8115 }
8116 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8117 1, strsec->sh_size,
8118 _("string table"));
8119 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8120 }
8121 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8122 unwsec = sec;
8123 }
8124
8125 if (!unwsec)
8126 printf (_("\nThere are no unwind sections in this file.\n"));
8127
8128 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8129 {
8130 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8131 {
8132 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8133
8134 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8135 "contains %lu entry:\n",
8136 "\nUnwind section '%s' at offset 0x%lx "
8137 "contains %lu entries:\n",
8138 num_unwind),
8139 printable_section_name (filedata, sec),
8140 (unsigned long) sec->sh_offset,
8141 num_unwind);
8142
8143 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8144 res = FALSE;
8145
8146 if (res && aux.table_len > 0)
8147 {
8148 if (! dump_hppa_unwind (filedata, &aux))
8149 res = FALSE;
8150 }
8151
8152 if (aux.table)
8153 free ((char *) aux.table);
8154 aux.table = NULL;
8155 }
8156 }
8157
8158 if (aux.symtab)
8159 free (aux.symtab);
8160 if (aux.strtab)
8161 free ((char *) aux.strtab);
8162
8163 return res;
8164}
8165
8166struct arm_section
8167{
8168 unsigned char * data; /* The unwind data. */
8169 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8170 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8171 unsigned long nrelas; /* The number of relocations. */
8172 unsigned int rel_type; /* REL or RELA ? */
8173 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8174};
8175
8176struct arm_unw_aux_info
8177{
8178 Filedata * filedata; /* The file containing the unwind sections. */
8179 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8180 unsigned long nsyms; /* Number of symbols. */
8181 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8182 unsigned long nfuns; /* Number of these symbols. */
8183 char * strtab; /* The file's string table. */
8184 unsigned long strtab_size; /* Size of string table. */
8185};
8186
8187static const char *
8188arm_print_vma_and_name (Filedata * filedata,
8189 struct arm_unw_aux_info * aux,
8190 bfd_vma fn,
8191 struct absaddr addr)
8192{
8193 const char *procname;
8194 bfd_vma sym_offset;
8195
8196 if (addr.section == SHN_UNDEF)
8197 addr.offset = fn;
8198
8199 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8200 aux->strtab_size, addr, &procname,
8201 &sym_offset);
8202
8203 print_vma (fn, PREFIX_HEX);
8204
8205 if (procname)
8206 {
8207 fputs (" <", stdout);
8208 fputs (procname, stdout);
8209
8210 if (sym_offset)
8211 printf ("+0x%lx", (unsigned long) sym_offset);
8212 fputc ('>', stdout);
8213 }
8214
8215 return procname;
8216}
8217
8218static void
8219arm_free_section (struct arm_section *arm_sec)
8220{
8221 if (arm_sec->data != NULL)
8222 free (arm_sec->data);
8223
8224 if (arm_sec->rela != NULL)
8225 free (arm_sec->rela);
8226}
8227
8228/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8229 cached section and install SEC instead.
8230 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8231 and return its valued in * WORDP, relocating if necessary.
8232 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8233 relocation's offset in ADDR.
8234 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8235 into the string table of the symbol associated with the reloc. If no
8236 reloc was applied store -1 there.
8237 5) Return TRUE upon success, FALSE otherwise. */
8238
8239static bfd_boolean
8240get_unwind_section_word (Filedata * filedata,
8241 struct arm_unw_aux_info * aux,
8242 struct arm_section * arm_sec,
8243 Elf_Internal_Shdr * sec,
8244 bfd_vma word_offset,
8245 unsigned int * wordp,
8246 struct absaddr * addr,
8247 bfd_vma * sym_name)
8248{
8249 Elf_Internal_Rela *rp;
8250 Elf_Internal_Sym *sym;
8251 const char * relname;
8252 unsigned int word;
8253 bfd_boolean wrapped;
8254
8255 if (sec == NULL || arm_sec == NULL)
8256 return FALSE;
8257
8258 addr->section = SHN_UNDEF;
8259 addr->offset = 0;
8260
8261 if (sym_name != NULL)
8262 *sym_name = (bfd_vma) -1;
8263
8264 /* If necessary, update the section cache. */
8265 if (sec != arm_sec->sec)
8266 {
8267 Elf_Internal_Shdr *relsec;
8268
8269 arm_free_section (arm_sec);
8270
8271 arm_sec->sec = sec;
8272 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8273 sec->sh_size, _("unwind data"));
8274 arm_sec->rela = NULL;
8275 arm_sec->nrelas = 0;
8276
8277 for (relsec = filedata->section_headers;
8278 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8279 ++relsec)
8280 {
8281 if (relsec->sh_info >= filedata->file_header.e_shnum
8282 || filedata->section_headers + relsec->sh_info != sec
8283 /* PR 15745: Check the section type as well. */
8284 || (relsec->sh_type != SHT_REL
8285 && relsec->sh_type != SHT_RELA))
8286 continue;
8287
8288 arm_sec->rel_type = relsec->sh_type;
8289 if (relsec->sh_type == SHT_REL)
8290 {
8291 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8292 relsec->sh_size,
8293 & arm_sec->rela, & arm_sec->nrelas))
8294 return FALSE;
8295 }
8296 else /* relsec->sh_type == SHT_RELA */
8297 {
8298 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8299 relsec->sh_size,
8300 & arm_sec->rela, & arm_sec->nrelas))
8301 return FALSE;
8302 }
8303 break;
8304 }
8305
8306 arm_sec->next_rela = arm_sec->rela;
8307 }
8308
8309 /* If there is no unwind data we can do nothing. */
8310 if (arm_sec->data == NULL)
8311 return FALSE;
8312
8313 /* If the offset is invalid then fail. */
8314 if (/* PR 21343 *//* PR 18879 */
8315 sec->sh_size < 4
8316 || word_offset > (sec->sh_size - 4)
8317 || ((bfd_signed_vma) word_offset) < 0)
8318 return FALSE;
8319
8320 /* Get the word at the required offset. */
8321 word = byte_get (arm_sec->data + word_offset, 4);
8322
8323 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8324 if (arm_sec->rela == NULL)
8325 {
8326 * wordp = word;
8327 return TRUE;
8328 }
8329
8330 /* Look through the relocs to find the one that applies to the provided offset. */
8331 wrapped = FALSE;
8332 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8333 {
8334 bfd_vma prelval, offset;
8335
8336 if (rp->r_offset > word_offset && !wrapped)
8337 {
8338 rp = arm_sec->rela;
8339 wrapped = TRUE;
8340 }
8341 if (rp->r_offset > word_offset)
8342 break;
8343
8344 if (rp->r_offset & 3)
8345 {
8346 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8347 (unsigned long) rp->r_offset);
8348 continue;
8349 }
8350
8351 if (rp->r_offset < word_offset)
8352 continue;
8353
8354 /* PR 17531: file: 027-161405-0.004 */
8355 if (aux->symtab == NULL)
8356 continue;
8357
8358 if (arm_sec->rel_type == SHT_REL)
8359 {
8360 offset = word & 0x7fffffff;
8361 if (offset & 0x40000000)
8362 offset |= ~ (bfd_vma) 0x7fffffff;
8363 }
8364 else if (arm_sec->rel_type == SHT_RELA)
8365 offset = rp->r_addend;
8366 else
8367 {
8368 error (_("Unknown section relocation type %d encountered\n"),
8369 arm_sec->rel_type);
8370 break;
8371 }
8372
8373 /* PR 17531 file: 027-1241568-0.004. */
8374 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8375 {
8376 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8377 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8378 break;
8379 }
8380
8381 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8382 offset += sym->st_value;
8383 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8384
8385 /* Check that we are processing the expected reloc type. */
8386 if (filedata->file_header.e_machine == EM_ARM)
8387 {
8388 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8389 if (relname == NULL)
8390 {
8391 warn (_("Skipping unknown ARM relocation type: %d\n"),
8392 (int) ELF32_R_TYPE (rp->r_info));
8393 continue;
8394 }
8395
8396 if (streq (relname, "R_ARM_NONE"))
8397 continue;
8398
8399 if (! streq (relname, "R_ARM_PREL31"))
8400 {
8401 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8402 continue;
8403 }
8404 }
8405 else if (filedata->file_header.e_machine == EM_TI_C6000)
8406 {
8407 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8408 if (relname == NULL)
8409 {
8410 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8411 (int) ELF32_R_TYPE (rp->r_info));
8412 continue;
8413 }
8414
8415 if (streq (relname, "R_C6000_NONE"))
8416 continue;
8417
8418 if (! streq (relname, "R_C6000_PREL31"))
8419 {
8420 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8421 continue;
8422 }
8423
8424 prelval >>= 1;
8425 }
8426 else
8427 {
8428 /* This function currently only supports ARM and TI unwinders. */
8429 warn (_("Only TI and ARM unwinders are currently supported\n"));
8430 break;
8431 }
8432
8433 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8434 addr->section = sym->st_shndx;
8435 addr->offset = offset;
8436
8437 if (sym_name)
8438 * sym_name = sym->st_name;
8439 break;
8440 }
8441
8442 *wordp = word;
8443 arm_sec->next_rela = rp;
8444
8445 return TRUE;
8446}
8447
8448static const char *tic6x_unwind_regnames[16] =
8449{
8450 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8451 "A14", "A13", "A12", "A11", "A10",
8452 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8453};
8454
8455static void
8456decode_tic6x_unwind_regmask (unsigned int mask)
8457{
8458 int i;
8459
8460 for (i = 12; mask; mask >>= 1, i--)
8461 {
8462 if (mask & 1)
8463 {
8464 fputs (tic6x_unwind_regnames[i], stdout);
8465 if (mask > 1)
8466 fputs (", ", stdout);
8467 }
8468 }
8469}
8470
8471#define ADVANCE \
8472 if (remaining == 0 && more_words) \
8473 { \
8474 data_offset += 4; \
8475 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8476 data_offset, & word, & addr, NULL)) \
8477 return FALSE; \
8478 remaining = 4; \
8479 more_words--; \
8480 } \
8481
8482#define GET_OP(OP) \
8483 ADVANCE; \
8484 if (remaining) \
8485 { \
8486 remaining--; \
8487 (OP) = word >> 24; \
8488 word <<= 8; \
8489 } \
8490 else \
8491 { \
8492 printf (_("[Truncated opcode]\n")); \
8493 return FALSE; \
8494 } \
8495 printf ("0x%02x ", OP)
8496
8497static bfd_boolean
8498decode_arm_unwind_bytecode (Filedata * filedata,
8499 struct arm_unw_aux_info * aux,
8500 unsigned int word,
8501 unsigned int remaining,
8502 unsigned int more_words,
8503 bfd_vma data_offset,
8504 Elf_Internal_Shdr * data_sec,
8505 struct arm_section * data_arm_sec)
8506{
8507 struct absaddr addr;
8508 bfd_boolean res = TRUE;
8509
8510 /* Decode the unwinding instructions. */
8511 while (1)
8512 {
8513 unsigned int op, op2;
8514
8515 ADVANCE;
8516 if (remaining == 0)
8517 break;
8518 remaining--;
8519 op = word >> 24;
8520 word <<= 8;
8521
8522 printf (" 0x%02x ", op);
8523
8524 if ((op & 0xc0) == 0x00)
8525 {
8526 int offset = ((op & 0x3f) << 2) + 4;
8527
8528 printf (" vsp = vsp + %d", offset);
8529 }
8530 else if ((op & 0xc0) == 0x40)
8531 {
8532 int offset = ((op & 0x3f) << 2) + 4;
8533
8534 printf (" vsp = vsp - %d", offset);
8535 }
8536 else if ((op & 0xf0) == 0x80)
8537 {
8538 GET_OP (op2);
8539 if (op == 0x80 && op2 == 0)
8540 printf (_("Refuse to unwind"));
8541 else
8542 {
8543 unsigned int mask = ((op & 0x0f) << 8) | op2;
8544 bfd_boolean first = TRUE;
8545 int i;
8546
8547 printf ("pop {");
8548 for (i = 0; i < 12; i++)
8549 if (mask & (1 << i))
8550 {
8551 if (first)
8552 first = FALSE;
8553 else
8554 printf (", ");
8555 printf ("r%d", 4 + i);
8556 }
8557 printf ("}");
8558 }
8559 }
8560 else if ((op & 0xf0) == 0x90)
8561 {
8562 if (op == 0x9d || op == 0x9f)
8563 printf (_(" [Reserved]"));
8564 else
8565 printf (" vsp = r%d", op & 0x0f);
8566 }
8567 else if ((op & 0xf0) == 0xa0)
8568 {
8569 int end = 4 + (op & 0x07);
8570 bfd_boolean first = TRUE;
8571 int i;
8572
8573 printf (" pop {");
8574 for (i = 4; i <= end; i++)
8575 {
8576 if (first)
8577 first = FALSE;
8578 else
8579 printf (", ");
8580 printf ("r%d", i);
8581 }
8582 if (op & 0x08)
8583 {
8584 if (!first)
8585 printf (", ");
8586 printf ("r14");
8587 }
8588 printf ("}");
8589 }
8590 else if (op == 0xb0)
8591 printf (_(" finish"));
8592 else if (op == 0xb1)
8593 {
8594 GET_OP (op2);
8595 if (op2 == 0 || (op2 & 0xf0) != 0)
8596 printf (_("[Spare]"));
8597 else
8598 {
8599 unsigned int mask = op2 & 0x0f;
8600 bfd_boolean first = TRUE;
8601 int i;
8602
8603 printf ("pop {");
8604 for (i = 0; i < 12; i++)
8605 if (mask & (1 << i))
8606 {
8607 if (first)
8608 first = FALSE;
8609 else
8610 printf (", ");
8611 printf ("r%d", i);
8612 }
8613 printf ("}");
8614 }
8615 }
8616 else if (op == 0xb2)
8617 {
8618 unsigned char buf[9];
8619 unsigned int i, len;
8620 unsigned long offset;
8621
8622 for (i = 0; i < sizeof (buf); i++)
8623 {
8624 GET_OP (buf[i]);
8625 if ((buf[i] & 0x80) == 0)
8626 break;
8627 }
8628 if (i == sizeof (buf))
8629 {
8630 error (_("corrupt change to vsp"));
8631 res = FALSE;
8632 }
8633 else
8634 {
8635 offset = read_uleb128 (buf, &len, buf + i + 1);
8636 assert (len == i + 1);
8637 offset = offset * 4 + 0x204;
8638 printf ("vsp = vsp + %ld", offset);
8639 }
8640 }
8641 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8642 {
8643 unsigned int first, last;
8644
8645 GET_OP (op2);
8646 first = op2 >> 4;
8647 last = op2 & 0x0f;
8648 if (op == 0xc8)
8649 first = first + 16;
8650 printf ("pop {D%d", first);
8651 if (last)
8652 printf ("-D%d", first + last);
8653 printf ("}");
8654 }
8655 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8656 {
8657 unsigned int count = op & 0x07;
8658
8659 printf ("pop {D8");
8660 if (count)
8661 printf ("-D%d", 8 + count);
8662 printf ("}");
8663 }
8664 else if (op >= 0xc0 && op <= 0xc5)
8665 {
8666 unsigned int count = op & 0x07;
8667
8668 printf (" pop {wR10");
8669 if (count)
8670 printf ("-wR%d", 10 + count);
8671 printf ("}");
8672 }
8673 else if (op == 0xc6)
8674 {
8675 unsigned int first, last;
8676
8677 GET_OP (op2);
8678 first = op2 >> 4;
8679 last = op2 & 0x0f;
8680 printf ("pop {wR%d", first);
8681 if (last)
8682 printf ("-wR%d", first + last);
8683 printf ("}");
8684 }
8685 else if (op == 0xc7)
8686 {
8687 GET_OP (op2);
8688 if (op2 == 0 || (op2 & 0xf0) != 0)
8689 printf (_("[Spare]"));
8690 else
8691 {
8692 unsigned int mask = op2 & 0x0f;
8693 bfd_boolean first = TRUE;
8694 int i;
8695
8696 printf ("pop {");
8697 for (i = 0; i < 4; i++)
8698 if (mask & (1 << i))
8699 {
8700 if (first)
8701 first = FALSE;
8702 else
8703 printf (", ");
8704 printf ("wCGR%d", i);
8705 }
8706 printf ("}");
8707 }
8708 }
8709 else
8710 {
8711 printf (_(" [unsupported opcode]"));
8712 res = FALSE;
8713 }
8714
8715 printf ("\n");
8716 }
8717
8718 return res;
8719}
8720
8721static bfd_boolean
8722decode_tic6x_unwind_bytecode (Filedata * filedata,
8723 struct arm_unw_aux_info * aux,
8724 unsigned int word,
8725 unsigned int remaining,
8726 unsigned int more_words,
8727 bfd_vma data_offset,
8728 Elf_Internal_Shdr * data_sec,
8729 struct arm_section * data_arm_sec)
8730{
8731 struct absaddr addr;
8732
8733 /* Decode the unwinding instructions. */
8734 while (1)
8735 {
8736 unsigned int op, op2;
8737
8738 ADVANCE;
8739 if (remaining == 0)
8740 break;
8741 remaining--;
8742 op = word >> 24;
8743 word <<= 8;
8744
8745 printf (" 0x%02x ", op);
8746
8747 if ((op & 0xc0) == 0x00)
8748 {
8749 int offset = ((op & 0x3f) << 3) + 8;
8750 printf (" sp = sp + %d", offset);
8751 }
8752 else if ((op & 0xc0) == 0x80)
8753 {
8754 GET_OP (op2);
8755 if (op == 0x80 && op2 == 0)
8756 printf (_("Refuse to unwind"));
8757 else
8758 {
8759 unsigned int mask = ((op & 0x1f) << 8) | op2;
8760 if (op & 0x20)
8761 printf ("pop compact {");
8762 else
8763 printf ("pop {");
8764
8765 decode_tic6x_unwind_regmask (mask);
8766 printf("}");
8767 }
8768 }
8769 else if ((op & 0xf0) == 0xc0)
8770 {
8771 unsigned int reg;
8772 unsigned int nregs;
8773 unsigned int i;
8774 const char *name;
8775 struct
8776 {
8777 unsigned int offset;
8778 unsigned int reg;
8779 } regpos[16];
8780
8781 /* Scan entire instruction first so that GET_OP output is not
8782 interleaved with disassembly. */
8783 nregs = 0;
8784 for (i = 0; nregs < (op & 0xf); i++)
8785 {
8786 GET_OP (op2);
8787 reg = op2 >> 4;
8788 if (reg != 0xf)
8789 {
8790 regpos[nregs].offset = i * 2;
8791 regpos[nregs].reg = reg;
8792 nregs++;
8793 }
8794
8795 reg = op2 & 0xf;
8796 if (reg != 0xf)
8797 {
8798 regpos[nregs].offset = i * 2 + 1;
8799 regpos[nregs].reg = reg;
8800 nregs++;
8801 }
8802 }
8803
8804 printf (_("pop frame {"));
8805 reg = nregs - 1;
8806 for (i = i * 2; i > 0; i--)
8807 {
8808 if (regpos[reg].offset == i - 1)
8809 {
8810 name = tic6x_unwind_regnames[regpos[reg].reg];
8811 if (reg > 0)
8812 reg--;
8813 }
8814 else
8815 name = _("[pad]");
8816
8817 fputs (name, stdout);
8818 if (i > 1)
8819 printf (", ");
8820 }
8821
8822 printf ("}");
8823 }
8824 else if (op == 0xd0)
8825 printf (" MOV FP, SP");
8826 else if (op == 0xd1)
8827 printf (" __c6xabi_pop_rts");
8828 else if (op == 0xd2)
8829 {
8830 unsigned char buf[9];
8831 unsigned int i, len;
8832 unsigned long offset;
8833
8834 for (i = 0; i < sizeof (buf); i++)
8835 {
8836 GET_OP (buf[i]);
8837 if ((buf[i] & 0x80) == 0)
8838 break;
8839 }
8840 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8841 if (i == sizeof (buf))
8842 {
8843 warn (_("Corrupt stack pointer adjustment detected\n"));
8844 return FALSE;
8845 }
8846
8847 offset = read_uleb128 (buf, &len, buf + i + 1);
8848 assert (len == i + 1);
8849 offset = offset * 8 + 0x408;
8850 printf (_("sp = sp + %ld"), offset);
8851 }
8852 else if ((op & 0xf0) == 0xe0)
8853 {
8854 if ((op & 0x0f) == 7)
8855 printf (" RETURN");
8856 else
8857 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8858 }
8859 else
8860 {
8861 printf (_(" [unsupported opcode]"));
8862 }
8863 putchar ('\n');
8864 }
8865
8866 return TRUE;
8867}
8868
8869static bfd_vma
8870arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8871{
8872 bfd_vma offset;
8873
8874 offset = word & 0x7fffffff;
8875 if (offset & 0x40000000)
8876 offset |= ~ (bfd_vma) 0x7fffffff;
8877
8878 if (filedata->file_header.e_machine == EM_TI_C6000)
8879 offset <<= 1;
8880
8881 return offset + where;
8882}
8883
8884static bfd_boolean
8885decode_arm_unwind (Filedata * filedata,
8886 struct arm_unw_aux_info * aux,
8887 unsigned int word,
8888 unsigned int remaining,
8889 bfd_vma data_offset,
8890 Elf_Internal_Shdr * data_sec,
8891 struct arm_section * data_arm_sec)
8892{
8893 int per_index;
8894 unsigned int more_words = 0;
8895 struct absaddr addr;
8896 bfd_vma sym_name = (bfd_vma) -1;
8897 bfd_boolean res = TRUE;
8898
8899 if (remaining == 0)
8900 {
8901 /* Fetch the first word.
8902 Note - when decoding an object file the address extracted
8903 here will always be 0. So we also pass in the sym_name
8904 parameter so that we can find the symbol associated with
8905 the personality routine. */
8906 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8907 & word, & addr, & sym_name))
8908 return FALSE;
8909
8910 remaining = 4;
8911 }
8912
8913 if ((word & 0x80000000) == 0)
8914 {
8915 /* Expand prel31 for personality routine. */
8916 bfd_vma fn;
8917 const char *procname;
8918
8919 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8920 printf (_(" Personality routine: "));
8921 if (fn == 0
8922 && addr.section == SHN_UNDEF && addr.offset == 0
8923 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8924 {
8925 procname = aux->strtab + sym_name;
8926 print_vma (fn, PREFIX_HEX);
8927 if (procname)
8928 {
8929 fputs (" <", stdout);
8930 fputs (procname, stdout);
8931 fputc ('>', stdout);
8932 }
8933 }
8934 else
8935 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8936 fputc ('\n', stdout);
8937
8938 /* The GCC personality routines use the standard compact
8939 encoding, starting with one byte giving the number of
8940 words. */
8941 if (procname != NULL
8942 && (const_strneq (procname, "__gcc_personality_v0")
8943 || const_strneq (procname, "__gxx_personality_v0")
8944 || const_strneq (procname, "__gcj_personality_v0")
8945 || const_strneq (procname, "__gnu_objc_personality_v0")))
8946 {
8947 remaining = 0;
8948 more_words = 1;
8949 ADVANCE;
8950 if (!remaining)
8951 {
8952 printf (_(" [Truncated data]\n"));
8953 return FALSE;
8954 }
8955 more_words = word >> 24;
8956 word <<= 8;
8957 remaining--;
8958 per_index = -1;
8959 }
8960 else
8961 return TRUE;
8962 }
8963 else
8964 {
8965 /* ARM EHABI Section 6.3:
8966
8967 An exception-handling table entry for the compact model looks like:
8968
8969 31 30-28 27-24 23-0
8970 -- ----- ----- ----
8971 1 0 index Data for personalityRoutine[index] */
8972
8973 if (filedata->file_header.e_machine == EM_ARM
8974 && (word & 0x70000000))
8975 {
8976 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8977 res = FALSE;
8978 }
8979
8980 per_index = (word >> 24) & 0x7f;
8981 printf (_(" Compact model index: %d\n"), per_index);
8982 if (per_index == 0)
8983 {
8984 more_words = 0;
8985 word <<= 8;
8986 remaining--;
8987 }
8988 else if (per_index < 3)
8989 {
8990 more_words = (word >> 16) & 0xff;
8991 word <<= 16;
8992 remaining -= 2;
8993 }
8994 }
8995
8996 switch (filedata->file_header.e_machine)
8997 {
8998 case EM_ARM:
8999 if (per_index < 3)
9000 {
9001 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9002 data_offset, data_sec, data_arm_sec))
9003 res = FALSE;
9004 }
9005 else
9006 {
9007 warn (_("Unknown ARM compact model index encountered\n"));
9008 printf (_(" [reserved]\n"));
9009 res = FALSE;
9010 }
9011 break;
9012
9013 case EM_TI_C6000:
9014 if (per_index < 3)
9015 {
9016 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9017 data_offset, data_sec, data_arm_sec))
9018 res = FALSE;
9019 }
9020 else if (per_index < 5)
9021 {
9022 if (((word >> 17) & 0x7f) == 0x7f)
9023 printf (_(" Restore stack from frame pointer\n"));
9024 else
9025 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9026 printf (_(" Registers restored: "));
9027 if (per_index == 4)
9028 printf (" (compact) ");
9029 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9030 putchar ('\n');
9031 printf (_(" Return register: %s\n"),
9032 tic6x_unwind_regnames[word & 0xf]);
9033 }
9034 else
9035 printf (_(" [reserved (%d)]\n"), per_index);
9036 break;
9037
9038 default:
9039 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9040 filedata->file_header.e_machine);
9041 res = FALSE;
9042 }
9043
9044 /* Decode the descriptors. Not implemented. */
9045
9046 return res;
9047}
9048
9049static bfd_boolean
9050dump_arm_unwind (Filedata * filedata,
9051 struct arm_unw_aux_info * aux,
9052 Elf_Internal_Shdr * exidx_sec)
9053{
9054 struct arm_section exidx_arm_sec, extab_arm_sec;
9055 unsigned int i, exidx_len;
9056 unsigned long j, nfuns;
9057 bfd_boolean res = TRUE;
9058
9059 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9060 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9061 exidx_len = exidx_sec->sh_size / 8;
9062
9063 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9064 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9065 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9066 aux->funtab[nfuns++] = aux->symtab[j];
9067 aux->nfuns = nfuns;
9068 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9069
9070 for (i = 0; i < exidx_len; i++)
9071 {
9072 unsigned int exidx_fn, exidx_entry;
9073 struct absaddr fn_addr, entry_addr;
9074 bfd_vma fn;
9075
9076 fputc ('\n', stdout);
9077
9078 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9079 8 * i, & exidx_fn, & fn_addr, NULL)
9080 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9081 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9082 {
9083 free (aux->funtab);
9084 arm_free_section (& exidx_arm_sec);
9085 arm_free_section (& extab_arm_sec);
9086 return FALSE;
9087 }
9088
9089 /* ARM EHABI, Section 5:
9090 An index table entry consists of 2 words.
9091 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9092 if (exidx_fn & 0x80000000)
9093 {
9094 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9095 res = FALSE;
9096 }
9097
9098 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9099
9100 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9101 fputs (": ", stdout);
9102
9103 if (exidx_entry == 1)
9104 {
9105 print_vma (exidx_entry, PREFIX_HEX);
9106 fputs (" [cantunwind]\n", stdout);
9107 }
9108 else if (exidx_entry & 0x80000000)
9109 {
9110 print_vma (exidx_entry, PREFIX_HEX);
9111 fputc ('\n', stdout);
9112 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9113 }
9114 else
9115 {
9116 bfd_vma table, table_offset = 0;
9117 Elf_Internal_Shdr *table_sec;
9118
9119 fputs ("@", stdout);
9120 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9121 print_vma (table, PREFIX_HEX);
9122 printf ("\n");
9123
9124 /* Locate the matching .ARM.extab. */
9125 if (entry_addr.section != SHN_UNDEF
9126 && entry_addr.section < filedata->file_header.e_shnum)
9127 {
9128 table_sec = filedata->section_headers + entry_addr.section;
9129 table_offset = entry_addr.offset;
9130 /* PR 18879 */
9131 if (table_offset > table_sec->sh_size
9132 || ((bfd_signed_vma) table_offset) < 0)
9133 {
9134 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9135 (unsigned long) table_offset,
9136 printable_section_name (filedata, table_sec));
9137 res = FALSE;
9138 continue;
9139 }
9140 }
9141 else
9142 {
9143 table_sec = find_section_by_address (filedata, table);
9144 if (table_sec != NULL)
9145 table_offset = table - table_sec->sh_addr;
9146 }
9147
9148 if (table_sec == NULL)
9149 {
9150 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9151 (unsigned long) table);
9152 res = FALSE;
9153 continue;
9154 }
9155
9156 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9157 &extab_arm_sec))
9158 res = FALSE;
9159 }
9160 }
9161
9162 printf ("\n");
9163
9164 free (aux->funtab);
9165 arm_free_section (&exidx_arm_sec);
9166 arm_free_section (&extab_arm_sec);
9167
9168 return res;
9169}
9170
9171/* Used for both ARM and C6X unwinding tables. */
9172
9173static bfd_boolean
9174arm_process_unwind (Filedata * filedata)
9175{
9176 struct arm_unw_aux_info aux;
9177 Elf_Internal_Shdr *unwsec = NULL;
9178 Elf_Internal_Shdr *strsec;
9179 Elf_Internal_Shdr *sec;
9180 unsigned long i;
9181 unsigned int sec_type;
9182 bfd_boolean res = TRUE;
9183
9184 switch (filedata->file_header.e_machine)
9185 {
9186 case EM_ARM:
9187 sec_type = SHT_ARM_EXIDX;
9188 break;
9189
9190 case EM_TI_C6000:
9191 sec_type = SHT_C6000_UNWIND;
9192 break;
9193
9194 default:
9195 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9196 filedata->file_header.e_machine);
9197 return FALSE;
9198 }
9199
9200 if (filedata->string_table == NULL)
9201 return FALSE;
9202
9203 memset (& aux, 0, sizeof (aux));
9204 aux.filedata = filedata;
9205
9206 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9207 {
9208 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9209 {
9210 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9211
9212 strsec = filedata->section_headers + sec->sh_link;
9213
9214 /* PR binutils/17531 file: 011-12666-0.004. */
9215 if (aux.strtab != NULL)
9216 {
9217 error (_("Multiple string tables found in file.\n"));
9218 free (aux.strtab);
9219 res = FALSE;
9220 }
9221 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9222 1, strsec->sh_size, _("string table"));
9223 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9224 }
9225 else if (sec->sh_type == sec_type)
9226 unwsec = sec;
9227 }
9228
9229 if (unwsec == NULL)
9230 printf (_("\nThere are no unwind sections in this file.\n"));
9231 else
9232 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9233 {
9234 if (sec->sh_type == sec_type)
9235 {
9236 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9237 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9238 "contains %lu entry:\n",
9239 "\nUnwind section '%s' at offset 0x%lx "
9240 "contains %lu entries:\n",
9241 num_unwind),
9242 printable_section_name (filedata, sec),
9243 (unsigned long) sec->sh_offset,
9244 num_unwind);
9245
9246 if (! dump_arm_unwind (filedata, &aux, sec))
9247 res = FALSE;
9248 }
9249 }
9250
9251 if (aux.symtab)
9252 free (aux.symtab);
9253 if (aux.strtab)
9254 free ((char *) aux.strtab);
9255
9256 return res;
9257}
9258
9259static bfd_boolean
9260process_unwind (Filedata * filedata)
9261{
9262 struct unwind_handler
9263 {
9264 unsigned int machtype;
9265 bfd_boolean (* handler)(Filedata *);
9266 } handlers[] =
9267 {
9268 { EM_ARM, arm_process_unwind },
9269 { EM_IA_64, ia64_process_unwind },
9270 { EM_PARISC, hppa_process_unwind },
9271 { EM_TI_C6000, arm_process_unwind },
9272 { 0, NULL }
9273 };
9274 int i;
9275
9276 if (!do_unwind)
9277 return TRUE;
9278
9279 for (i = 0; handlers[i].handler != NULL; i++)
9280 if (filedata->file_header.e_machine == handlers[i].machtype)
9281 return handlers[i].handler (filedata);
9282
9283 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9284 get_machine_name (filedata->file_header.e_machine));
9285 return TRUE;
9286}
9287
9288static void
9289dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9290{
9291 switch (entry->d_tag)
9292 {
9293 case DT_MIPS_FLAGS:
9294 if (entry->d_un.d_val == 0)
9295 printf (_("NONE"));
9296 else
9297 {
9298 static const char * opts[] =
9299 {
9300 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9301 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9302 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9303 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9304 "RLD_ORDER_SAFE"
9305 };
9306 unsigned int cnt;
9307 bfd_boolean first = TRUE;
9308
9309 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9310 if (entry->d_un.d_val & (1 << cnt))
9311 {
9312 printf ("%s%s", first ? "" : " ", opts[cnt]);
9313 first = FALSE;
9314 }
9315 }
9316 break;
9317
9318 case DT_MIPS_IVERSION:
9319 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9320 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9321 else
9322 {
9323 char buf[40];
9324 sprintf_vma (buf, entry->d_un.d_ptr);
9325 /* Note: coded this way so that there is a single string for translation. */
9326 printf (_("<corrupt: %s>"), buf);
9327 }
9328 break;
9329
9330 case DT_MIPS_TIME_STAMP:
9331 {
9332 char timebuf[128];
9333 struct tm * tmp;
9334 time_t atime = entry->d_un.d_val;
9335
9336 tmp = gmtime (&atime);
9337 /* PR 17531: file: 6accc532. */
9338 if (tmp == NULL)
9339 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9340 else
9341 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9342 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9343 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9344 printf (_("Time Stamp: %s"), timebuf);
9345 }
9346 break;
9347
9348 case DT_MIPS_RLD_VERSION:
9349 case DT_MIPS_LOCAL_GOTNO:
9350 case DT_MIPS_CONFLICTNO:
9351 case DT_MIPS_LIBLISTNO:
9352 case DT_MIPS_SYMTABNO:
9353 case DT_MIPS_UNREFEXTNO:
9354 case DT_MIPS_HIPAGENO:
9355 case DT_MIPS_DELTA_CLASS_NO:
9356 case DT_MIPS_DELTA_INSTANCE_NO:
9357 case DT_MIPS_DELTA_RELOC_NO:
9358 case DT_MIPS_DELTA_SYM_NO:
9359 case DT_MIPS_DELTA_CLASSSYM_NO:
9360 case DT_MIPS_COMPACT_SIZE:
9361 print_vma (entry->d_un.d_val, DEC);
9362 break;
9363
9364 default:
9365 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9366 }
9367 putchar ('\n');
9368}
9369
9370static void
9371dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9372{
9373 switch (entry->d_tag)
9374 {
9375 case DT_HP_DLD_FLAGS:
9376 {
9377 static struct
9378 {
9379 long int bit;
9380 const char * str;
9381 }
9382 flags[] =
9383 {
9384 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9385 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9386 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9387 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9388 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9389 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9390 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9391 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9392 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9393 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9394 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9395 { DT_HP_GST, "HP_GST" },
9396 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9397 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9398 { DT_HP_NODELETE, "HP_NODELETE" },
9399 { DT_HP_GROUP, "HP_GROUP" },
9400 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9401 };
9402 bfd_boolean first = TRUE;
9403 size_t cnt;
9404 bfd_vma val = entry->d_un.d_val;
9405
9406 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9407 if (val & flags[cnt].bit)
9408 {
9409 if (! first)
9410 putchar (' ');
9411 fputs (flags[cnt].str, stdout);
9412 first = FALSE;
9413 val ^= flags[cnt].bit;
9414 }
9415
9416 if (val != 0 || first)
9417 {
9418 if (! first)
9419 putchar (' ');
9420 print_vma (val, HEX);
9421 }
9422 }
9423 break;
9424
9425 default:
9426 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9427 break;
9428 }
9429 putchar ('\n');
9430}
9431
9432#ifdef BFD64
9433
9434/* VMS vs Unix time offset and factor. */
9435
9436#define VMS_EPOCH_OFFSET 35067168000000000LL
9437#define VMS_GRANULARITY_FACTOR 10000000
9438
9439/* Display a VMS time in a human readable format. */
9440
9441static void
9442print_vms_time (bfd_int64_t vmstime)
9443{
9444 struct tm *tm;
9445 time_t unxtime;
9446
9447 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9448 tm = gmtime (&unxtime);
9449 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9450 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9451 tm->tm_hour, tm->tm_min, tm->tm_sec);
9452}
9453#endif /* BFD64 */
9454
9455static void
9456dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9457{
9458 switch (entry->d_tag)
9459 {
9460 case DT_IA_64_PLT_RESERVE:
9461 /* First 3 slots reserved. */
9462 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9463 printf (" -- ");
9464 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9465 break;
9466
9467 case DT_IA_64_VMS_LINKTIME:
9468#ifdef BFD64
9469 print_vms_time (entry->d_un.d_val);
9470#endif
9471 break;
9472
9473 case DT_IA_64_VMS_LNKFLAGS:
9474 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9475 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9476 printf (" CALL_DEBUG");
9477 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9478 printf (" NOP0BUFS");
9479 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9480 printf (" P0IMAGE");
9481 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9482 printf (" MKTHREADS");
9483 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9484 printf (" UPCALLS");
9485 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9486 printf (" IMGSTA");
9487 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9488 printf (" INITIALIZE");
9489 if (entry->d_un.d_val & VMS_LF_MAIN)
9490 printf (" MAIN");
9491 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9492 printf (" EXE_INIT");
9493 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9494 printf (" TBK_IN_IMG");
9495 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9496 printf (" DBG_IN_IMG");
9497 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9498 printf (" TBK_IN_DSF");
9499 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9500 printf (" DBG_IN_DSF");
9501 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9502 printf (" SIGNATURES");
9503 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9504 printf (" REL_SEG_OFF");
9505 break;
9506
9507 default:
9508 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9509 break;
9510 }
9511 putchar ('\n');
9512}
9513
9514static bfd_boolean
9515get_32bit_dynamic_section (Filedata * filedata)
9516{
9517 Elf32_External_Dyn * edyn;
9518 Elf32_External_Dyn * ext;
9519 Elf_Internal_Dyn * entry;
9520
9521 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9522 dynamic_size, _("dynamic section"));
9523 if (!edyn)
9524 return FALSE;
9525
9526 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9527 might not have the luxury of section headers. Look for the DT_NULL
9528 terminator to determine the number of entries. */
9529 for (ext = edyn, dynamic_nent = 0;
9530 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9531 ext++)
9532 {
9533 dynamic_nent++;
9534 if (BYTE_GET (ext->d_tag) == DT_NULL)
9535 break;
9536 }
9537
9538 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9539 sizeof (* entry));
9540 if (dynamic_section == NULL)
9541 {
9542 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9543 (unsigned long) dynamic_nent);
9544 free (edyn);
9545 return FALSE;
9546 }
9547
9548 for (ext = edyn, entry = dynamic_section;
9549 entry < dynamic_section + dynamic_nent;
9550 ext++, entry++)
9551 {
9552 entry->d_tag = BYTE_GET (ext->d_tag);
9553 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9554 }
9555
9556 free (edyn);
9557
9558 return TRUE;
9559}
9560
9561static bfd_boolean
9562get_64bit_dynamic_section (Filedata * filedata)
9563{
9564 Elf64_External_Dyn * edyn;
9565 Elf64_External_Dyn * ext;
9566 Elf_Internal_Dyn * entry;
9567
9568 /* Read in the data. */
9569 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9570 dynamic_size, _("dynamic section"));
9571 if (!edyn)
9572 return FALSE;
9573
9574 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9575 might not have the luxury of section headers. Look for the DT_NULL
9576 terminator to determine the number of entries. */
9577 for (ext = edyn, dynamic_nent = 0;
9578 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9579 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9580 ext++)
9581 {
9582 dynamic_nent++;
9583 if (BYTE_GET (ext->d_tag) == DT_NULL)
9584 break;
9585 }
9586
9587 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9588 sizeof (* entry));
9589 if (dynamic_section == NULL)
9590 {
9591 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9592 (unsigned long) dynamic_nent);
9593 free (edyn);
9594 return FALSE;
9595 }
9596
9597 /* Convert from external to internal formats. */
9598 for (ext = edyn, entry = dynamic_section;
9599 entry < dynamic_section + dynamic_nent;
9600 ext++, entry++)
9601 {
9602 entry->d_tag = BYTE_GET (ext->d_tag);
9603 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9604 }
9605
9606 free (edyn);
9607
9608 return TRUE;
9609}
9610
9611static void
9612print_dynamic_flags (bfd_vma flags)
9613{
9614 bfd_boolean first = TRUE;
9615
9616 while (flags)
9617 {
9618 bfd_vma flag;
9619
9620 flag = flags & - flags;
9621 flags &= ~ flag;
9622
9623 if (first)
9624 first = FALSE;
9625 else
9626 putc (' ', stdout);
9627
9628 switch (flag)
9629 {
9630 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9631 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9632 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9633 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9634 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9635 default: fputs (_("unknown"), stdout); break;
9636 }
9637 }
9638 puts ("");
9639}
9640
9641/* Parse and display the contents of the dynamic section. */
9642
9643static bfd_boolean
9644process_dynamic_section (Filedata * filedata)
9645{
9646 Elf_Internal_Dyn * entry;
9647
9648 if (dynamic_size == 0)
9649 {
9650 if (do_dynamic)
9651 printf (_("\nThere is no dynamic section in this file.\n"));
9652
9653 return TRUE;
9654 }
9655
9656 if (is_32bit_elf)
9657 {
9658 if (! get_32bit_dynamic_section (filedata))
9659 return FALSE;
9660 }
9661 else
9662 {
9663 if (! get_64bit_dynamic_section (filedata))
9664 return FALSE;
9665 }
9666
9667 /* Find the appropriate symbol table. */
9668 if (dynamic_symbols == NULL)
9669 {
9670 for (entry = dynamic_section;
9671 entry < dynamic_section + dynamic_nent;
9672 ++entry)
9673 {
9674 Elf_Internal_Shdr section;
9675
9676 if (entry->d_tag != DT_SYMTAB)
9677 continue;
9678
9679 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9680
9681 /* Since we do not know how big the symbol table is,
9682 we default to reading in the entire file (!) and
9683 processing that. This is overkill, I know, but it
9684 should work. */
9685 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9686 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9687 {
9688 /* See PR 21379 for a reproducer. */
9689 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9690 return FALSE;
9691 }
9692
9693 if (archive_file_offset != 0)
9694 section.sh_size = archive_file_size - section.sh_offset;
9695 else
9696 section.sh_size = filedata->file_size - section.sh_offset;
9697
9698 if (is_32bit_elf)
9699 section.sh_entsize = sizeof (Elf32_External_Sym);
9700 else
9701 section.sh_entsize = sizeof (Elf64_External_Sym);
9702 section.sh_name = filedata->string_table_length;
9703
9704 if (dynamic_symbols != NULL)
9705 {
9706 error (_("Multiple dynamic symbol table sections found\n"));
9707 free (dynamic_symbols);
9708 }
9709 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9710 if (num_dynamic_syms < 1)
9711 {
9712 error (_("Unable to determine the number of symbols to load\n"));
9713 continue;
9714 }
9715 }
9716 }
9717
9718 /* Similarly find a string table. */
9719 if (dynamic_strings == NULL)
9720 {
9721 for (entry = dynamic_section;
9722 entry < dynamic_section + dynamic_nent;
9723 ++entry)
9724 {
9725 unsigned long offset;
9726 long str_tab_len;
9727
9728 if (entry->d_tag != DT_STRTAB)
9729 continue;
9730
9731 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9732
9733 /* Since we do not know how big the string table is,
9734 we default to reading in the entire file (!) and
9735 processing that. This is overkill, I know, but it
9736 should work. */
9737
9738 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9739
9740 if (archive_file_offset != 0)
9741 str_tab_len = archive_file_size - offset;
9742 else
9743 str_tab_len = filedata->file_size - offset;
9744
9745 if (str_tab_len < 1)
9746 {
9747 error
9748 (_("Unable to determine the length of the dynamic string table\n"));
9749 continue;
9750 }
9751
9752 if (dynamic_strings != NULL)
9753 {
9754 error (_("Multiple dynamic string tables found\n"));
9755 free (dynamic_strings);
9756 }
9757
9758 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9759 str_tab_len,
9760 _("dynamic string table"));
9761 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9762 }
9763 }
9764
9765 /* And find the syminfo section if available. */
9766 if (dynamic_syminfo == NULL)
9767 {
9768 unsigned long syminsz = 0;
9769
9770 for (entry = dynamic_section;
9771 entry < dynamic_section + dynamic_nent;
9772 ++entry)
9773 {
9774 if (entry->d_tag == DT_SYMINENT)
9775 {
9776 /* Note: these braces are necessary to avoid a syntax
9777 error from the SunOS4 C compiler. */
9778 /* PR binutils/17531: A corrupt file can trigger this test.
9779 So do not use an assert, instead generate an error message. */
9780 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9781 error (_("Bad value (%d) for SYMINENT entry\n"),
9782 (int) entry->d_un.d_val);
9783 }
9784 else if (entry->d_tag == DT_SYMINSZ)
9785 syminsz = entry->d_un.d_val;
9786 else if (entry->d_tag == DT_SYMINFO)
9787 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9788 syminsz);
9789 }
9790
9791 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9792 {
9793 Elf_External_Syminfo * extsyminfo;
9794 Elf_External_Syminfo * extsym;
9795 Elf_Internal_Syminfo * syminfo;
9796
9797 /* There is a syminfo section. Read the data. */
9798 extsyminfo = (Elf_External_Syminfo *)
9799 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9800 _("symbol information"));
9801 if (!extsyminfo)
9802 return FALSE;
9803
9804 if (dynamic_syminfo != NULL)
9805 {
9806 error (_("Multiple dynamic symbol information sections found\n"));
9807 free (dynamic_syminfo);
9808 }
9809 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9810 if (dynamic_syminfo == NULL)
9811 {
9812 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9813 (unsigned long) syminsz);
9814 return FALSE;
9815 }
9816
9817 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9818 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9819 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9820 ++syminfo, ++extsym)
9821 {
9822 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9823 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9824 }
9825
9826 free (extsyminfo);
9827 }
9828 }
9829
9830 if (do_dynamic && dynamic_addr)
9831 printf (ngettext ("\nDynamic section at offset 0x%lx "
9832 "contains %lu entry:\n",
9833 "\nDynamic section at offset 0x%lx "
9834 "contains %lu entries:\n",
9835 dynamic_nent),
9836 dynamic_addr, (unsigned long) dynamic_nent);
9837 if (do_dynamic)
9838 printf (_(" Tag Type Name/Value\n"));
9839
9840 for (entry = dynamic_section;
9841 entry < dynamic_section + dynamic_nent;
9842 entry++)
9843 {
9844 if (do_dynamic)
9845 {
9846 const char * dtype;
9847
9848 putchar (' ');
9849 print_vma (entry->d_tag, FULL_HEX);
9850 dtype = get_dynamic_type (filedata, entry->d_tag);
9851 printf (" (%s)%*s", dtype,
9852 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9853 }
9854
9855 switch (entry->d_tag)
9856 {
9857 case DT_FLAGS:
9858 if (do_dynamic)
9859 print_dynamic_flags (entry->d_un.d_val);
9860 break;
9861
9862 case DT_AUXILIARY:
9863 case DT_FILTER:
9864 case DT_CONFIG:
9865 case DT_DEPAUDIT:
9866 case DT_AUDIT:
9867 if (do_dynamic)
9868 {
9869 switch (entry->d_tag)
9870 {
9871 case DT_AUXILIARY:
9872 printf (_("Auxiliary library"));
9873 break;
9874
9875 case DT_FILTER:
9876 printf (_("Filter library"));
9877 break;
9878
9879 case DT_CONFIG:
9880 printf (_("Configuration file"));
9881 break;
9882
9883 case DT_DEPAUDIT:
9884 printf (_("Dependency audit library"));
9885 break;
9886
9887 case DT_AUDIT:
9888 printf (_("Audit library"));
9889 break;
9890 }
9891
9892 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9893 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9894 else
9895 {
9896 printf (": ");
9897 print_vma (entry->d_un.d_val, PREFIX_HEX);
9898 putchar ('\n');
9899 }
9900 }
9901 break;
9902
9903 case DT_FEATURE:
9904 if (do_dynamic)
9905 {
9906 printf (_("Flags:"));
9907
9908 if (entry->d_un.d_val == 0)
9909 printf (_(" None\n"));
9910 else
9911 {
9912 unsigned long int val = entry->d_un.d_val;
9913
9914 if (val & DTF_1_PARINIT)
9915 {
9916 printf (" PARINIT");
9917 val ^= DTF_1_PARINIT;
9918 }
9919 if (val & DTF_1_CONFEXP)
9920 {
9921 printf (" CONFEXP");
9922 val ^= DTF_1_CONFEXP;
9923 }
9924 if (val != 0)
9925 printf (" %lx", val);
9926 puts ("");
9927 }
9928 }
9929 break;
9930
9931 case DT_POSFLAG_1:
9932 if (do_dynamic)
9933 {
9934 printf (_("Flags:"));
9935
9936 if (entry->d_un.d_val == 0)
9937 printf (_(" None\n"));
9938 else
9939 {
9940 unsigned long int val = entry->d_un.d_val;
9941
9942 if (val & DF_P1_LAZYLOAD)
9943 {
9944 printf (" LAZYLOAD");
9945 val ^= DF_P1_LAZYLOAD;
9946 }
9947 if (val & DF_P1_GROUPPERM)
9948 {
9949 printf (" GROUPPERM");
9950 val ^= DF_P1_GROUPPERM;
9951 }
9952 if (val != 0)
9953 printf (" %lx", val);
9954 puts ("");
9955 }
9956 }
9957 break;
9958
9959 case DT_FLAGS_1:
9960 if (do_dynamic)
9961 {
9962 printf (_("Flags:"));
9963 if (entry->d_un.d_val == 0)
9964 printf (_(" None\n"));
9965 else
9966 {
9967 unsigned long int val = entry->d_un.d_val;
9968
9969 if (val & DF_1_NOW)
9970 {
9971 printf (" NOW");
9972 val ^= DF_1_NOW;
9973 }
9974 if (val & DF_1_GLOBAL)
9975 {
9976 printf (" GLOBAL");
9977 val ^= DF_1_GLOBAL;
9978 }
9979 if (val & DF_1_GROUP)
9980 {
9981 printf (" GROUP");
9982 val ^= DF_1_GROUP;
9983 }
9984 if (val & DF_1_NODELETE)
9985 {
9986 printf (" NODELETE");
9987 val ^= DF_1_NODELETE;
9988 }
9989 if (val & DF_1_LOADFLTR)
9990 {
9991 printf (" LOADFLTR");
9992 val ^= DF_1_LOADFLTR;
9993 }
9994 if (val & DF_1_INITFIRST)
9995 {
9996 printf (" INITFIRST");
9997 val ^= DF_1_INITFIRST;
9998 }
9999 if (val & DF_1_NOOPEN)
10000 {
10001 printf (" NOOPEN");
10002 val ^= DF_1_NOOPEN;
10003 }
10004 if (val & DF_1_ORIGIN)
10005 {
10006 printf (" ORIGIN");
10007 val ^= DF_1_ORIGIN;
10008 }
10009 if (val & DF_1_DIRECT)
10010 {
10011 printf (" DIRECT");
10012 val ^= DF_1_DIRECT;
10013 }
10014 if (val & DF_1_TRANS)
10015 {
10016 printf (" TRANS");
10017 val ^= DF_1_TRANS;
10018 }
10019 if (val & DF_1_INTERPOSE)
10020 {
10021 printf (" INTERPOSE");
10022 val ^= DF_1_INTERPOSE;
10023 }
10024 if (val & DF_1_NODEFLIB)
10025 {
10026 printf (" NODEFLIB");
10027 val ^= DF_1_NODEFLIB;
10028 }
10029 if (val & DF_1_NODUMP)
10030 {
10031 printf (" NODUMP");
10032 val ^= DF_1_NODUMP;
10033 }
10034 if (val & DF_1_CONFALT)
10035 {
10036 printf (" CONFALT");
10037 val ^= DF_1_CONFALT;
10038 }
10039 if (val & DF_1_ENDFILTEE)
10040 {
10041 printf (" ENDFILTEE");
10042 val ^= DF_1_ENDFILTEE;
10043 }
10044 if (val & DF_1_DISPRELDNE)
10045 {
10046 printf (" DISPRELDNE");
10047 val ^= DF_1_DISPRELDNE;
10048 }
10049 if (val & DF_1_DISPRELPND)
10050 {
10051 printf (" DISPRELPND");
10052 val ^= DF_1_DISPRELPND;
10053 }
10054 if (val & DF_1_NODIRECT)
10055 {
10056 printf (" NODIRECT");
10057 val ^= DF_1_NODIRECT;
10058 }
10059 if (val & DF_1_IGNMULDEF)
10060 {
10061 printf (" IGNMULDEF");
10062 val ^= DF_1_IGNMULDEF;
10063 }
10064 if (val & DF_1_NOKSYMS)
10065 {
10066 printf (" NOKSYMS");
10067 val ^= DF_1_NOKSYMS;
10068 }
10069 if (val & DF_1_NOHDR)
10070 {
10071 printf (" NOHDR");
10072 val ^= DF_1_NOHDR;
10073 }
10074 if (val & DF_1_EDITED)
10075 {
10076 printf (" EDITED");
10077 val ^= DF_1_EDITED;
10078 }
10079 if (val & DF_1_NORELOC)
10080 {
10081 printf (" NORELOC");
10082 val ^= DF_1_NORELOC;
10083 }
10084 if (val & DF_1_SYMINTPOSE)
10085 {
10086 printf (" SYMINTPOSE");
10087 val ^= DF_1_SYMINTPOSE;
10088 }
10089 if (val & DF_1_GLOBAUDIT)
10090 {
10091 printf (" GLOBAUDIT");
10092 val ^= DF_1_GLOBAUDIT;
10093 }
10094 if (val & DF_1_SINGLETON)
10095 {
10096 printf (" SINGLETON");
10097 val ^= DF_1_SINGLETON;
10098 }
10099 if (val & DF_1_STUB)
10100 {
10101 printf (" STUB");
10102 val ^= DF_1_STUB;
10103 }
10104 if (val & DF_1_PIE)
10105 {
10106 printf (" PIE");
10107 val ^= DF_1_PIE;
10108 }
10109 if (val & DF_1_KMOD)
10110 {
10111 printf (" KMOD");
10112 val ^= DF_1_KMOD;
10113 }
10114 if (val & DF_1_WEAKFILTER)
10115 {
10116 printf (" WEAKFILTER");
10117 val ^= DF_1_WEAKFILTER;
10118 }
10119 if (val & DF_1_NOCOMMON)
10120 {
10121 printf (" NOCOMMON");
10122 val ^= DF_1_NOCOMMON;
10123 }
10124 if (val != 0)
10125 printf (" %lx", val);
10126 puts ("");
10127 }
10128 }
10129 break;
10130
10131 case DT_PLTREL:
10132 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10133 if (do_dynamic)
10134 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10135 break;
10136
10137 case DT_NULL :
10138 case DT_NEEDED :
10139 case DT_PLTGOT :
10140 case DT_HASH :
10141 case DT_STRTAB :
10142 case DT_SYMTAB :
10143 case DT_RELA :
10144 case DT_INIT :
10145 case DT_FINI :
10146 case DT_SONAME :
10147 case DT_RPATH :
10148 case DT_SYMBOLIC:
10149 case DT_REL :
10150 case DT_DEBUG :
10151 case DT_TEXTREL :
10152 case DT_JMPREL :
10153 case DT_RUNPATH :
10154 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10155
10156 if (do_dynamic)
10157 {
10158 char * name;
10159
10160 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10161 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10162 else
10163 name = NULL;
10164
10165 if (name)
10166 {
10167 switch (entry->d_tag)
10168 {
10169 case DT_NEEDED:
10170 printf (_("Shared library: [%s]"), name);
10171
10172 if (streq (name, program_interpreter))
10173 printf (_(" program interpreter"));
10174 break;
10175
10176 case DT_SONAME:
10177 printf (_("Library soname: [%s]"), name);
10178 break;
10179
10180 case DT_RPATH:
10181 printf (_("Library rpath: [%s]"), name);
10182 break;
10183
10184 case DT_RUNPATH:
10185 printf (_("Library runpath: [%s]"), name);
10186 break;
10187
10188 default:
10189 print_vma (entry->d_un.d_val, PREFIX_HEX);
10190 break;
10191 }
10192 }
10193 else
10194 print_vma (entry->d_un.d_val, PREFIX_HEX);
10195
10196 putchar ('\n');
10197 }
10198 break;
10199
10200 case DT_PLTRELSZ:
10201 case DT_RELASZ :
10202 case DT_STRSZ :
10203 case DT_RELSZ :
10204 case DT_RELAENT :
10205 case DT_SYMENT :
10206 case DT_RELENT :
10207 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10208 /* Fall through. */
10209 case DT_PLTPADSZ:
10210 case DT_MOVEENT :
10211 case DT_MOVESZ :
10212 case DT_INIT_ARRAYSZ:
10213 case DT_FINI_ARRAYSZ:
10214 case DT_GNU_CONFLICTSZ:
10215 case DT_GNU_LIBLISTSZ:
10216 if (do_dynamic)
10217 {
10218 print_vma (entry->d_un.d_val, UNSIGNED);
10219 printf (_(" (bytes)\n"));
10220 }
10221 break;
10222
10223 case DT_VERDEFNUM:
10224 case DT_VERNEEDNUM:
10225 case DT_RELACOUNT:
10226 case DT_RELCOUNT:
10227 if (do_dynamic)
10228 {
10229 print_vma (entry->d_un.d_val, UNSIGNED);
10230 putchar ('\n');
10231 }
10232 break;
10233
10234 case DT_SYMINSZ:
10235 case DT_SYMINENT:
10236 case DT_SYMINFO:
10237 case DT_USED:
10238 case DT_INIT_ARRAY:
10239 case DT_FINI_ARRAY:
10240 if (do_dynamic)
10241 {
10242 if (entry->d_tag == DT_USED
10243 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10244 {
10245 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10246
10247 if (*name)
10248 {
10249 printf (_("Not needed object: [%s]\n"), name);
10250 break;
10251 }
10252 }
10253
10254 print_vma (entry->d_un.d_val, PREFIX_HEX);
10255 putchar ('\n');
10256 }
10257 break;
10258
10259 case DT_BIND_NOW:
10260 /* The value of this entry is ignored. */
10261 if (do_dynamic)
10262 putchar ('\n');
10263 break;
10264
10265 case DT_GNU_PRELINKED:
10266 if (do_dynamic)
10267 {
10268 struct tm * tmp;
10269 time_t atime = entry->d_un.d_val;
10270
10271 tmp = gmtime (&atime);
10272 /* PR 17533 file: 041-1244816-0.004. */
10273 if (tmp == NULL)
10274 printf (_("<corrupt time val: %lx"),
10275 (unsigned long) atime);
10276 else
10277 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10278 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10279 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10280
10281 }
10282 break;
10283
10284 case DT_GNU_HASH:
10285 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10286 if (do_dynamic)
10287 {
10288 print_vma (entry->d_un.d_val, PREFIX_HEX);
10289 putchar ('\n');
10290 }
10291 break;
10292
10293 default:
10294 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10295 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10296 entry->d_un.d_val;
10297
10298 if (do_dynamic)
10299 {
10300 switch (filedata->file_header.e_machine)
10301 {
10302 case EM_MIPS:
10303 case EM_MIPS_RS3_LE:
10304 dynamic_section_mips_val (entry);
10305 break;
10306 case EM_PARISC:
10307 dynamic_section_parisc_val (entry);
10308 break;
10309 case EM_IA_64:
10310 dynamic_section_ia64_val (entry);
10311 break;
10312 default:
10313 print_vma (entry->d_un.d_val, PREFIX_HEX);
10314 putchar ('\n');
10315 }
10316 }
10317 break;
10318 }
10319 }
10320
10321 return TRUE;
10322}
10323
10324static char *
10325get_ver_flags (unsigned int flags)
10326{
10327 static char buff[128];
10328
10329 buff[0] = 0;
10330
10331 if (flags == 0)
10332 return _("none");
10333
10334 if (flags & VER_FLG_BASE)
10335 strcat (buff, "BASE");
10336
10337 if (flags & VER_FLG_WEAK)
10338 {
10339 if (flags & VER_FLG_BASE)
10340 strcat (buff, " | ");
10341
10342 strcat (buff, "WEAK");
10343 }
10344
10345 if (flags & VER_FLG_INFO)
10346 {
10347 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10348 strcat (buff, " | ");
10349
10350 strcat (buff, "INFO");
10351 }
10352
10353 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10354 {
10355 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10356 strcat (buff, " | ");
10357
10358 strcat (buff, _("<unknown>"));
10359 }
10360
10361 return buff;
10362}
10363
10364/* Display the contents of the version sections. */
10365
10366static bfd_boolean
10367process_version_sections (Filedata * filedata)
10368{
10369 Elf_Internal_Shdr * section;
10370 unsigned i;
10371 bfd_boolean found = FALSE;
10372
10373 if (! do_version)
10374 return TRUE;
10375
10376 for (i = 0, section = filedata->section_headers;
10377 i < filedata->file_header.e_shnum;
10378 i++, section++)
10379 {
10380 switch (section->sh_type)
10381 {
10382 case SHT_GNU_verdef:
10383 {
10384 Elf_External_Verdef * edefs;
10385 unsigned long idx;
10386 unsigned long cnt;
10387 char * endbuf;
10388
10389 found = TRUE;
10390
10391 printf (ngettext ("\nVersion definition section '%s' "
10392 "contains %u entry:\n",
10393 "\nVersion definition section '%s' "
10394 "contains %u entries:\n",
10395 section->sh_info),
10396 printable_section_name (filedata, section),
10397 section->sh_info);
10398
10399 printf (_(" Addr: 0x"));
10400 printf_vma (section->sh_addr);
10401 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10402 (unsigned long) section->sh_offset, section->sh_link,
10403 printable_section_name_from_index (filedata, section->sh_link));
10404
10405 edefs = (Elf_External_Verdef *)
10406 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10407 _("version definition section"));
10408 if (!edefs)
10409 break;
10410 endbuf = (char *) edefs + section->sh_size;
10411
10412 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10413 {
10414 char * vstart;
10415 Elf_External_Verdef * edef;
10416 Elf_Internal_Verdef ent;
10417 Elf_External_Verdaux * eaux;
10418 Elf_Internal_Verdaux aux;
10419 unsigned long isum;
10420 int j;
10421
10422 vstart = ((char *) edefs) + idx;
10423 if (vstart + sizeof (*edef) > endbuf)
10424 break;
10425
10426 edef = (Elf_External_Verdef *) vstart;
10427
10428 ent.vd_version = BYTE_GET (edef->vd_version);
10429 ent.vd_flags = BYTE_GET (edef->vd_flags);
10430 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10431 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10432 ent.vd_hash = BYTE_GET (edef->vd_hash);
10433 ent.vd_aux = BYTE_GET (edef->vd_aux);
10434 ent.vd_next = BYTE_GET (edef->vd_next);
10435
10436 printf (_(" %#06lx: Rev: %d Flags: %s"),
10437 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10438
10439 printf (_(" Index: %d Cnt: %d "),
10440 ent.vd_ndx, ent.vd_cnt);
10441
10442 /* Check for overflow. */
10443 if (ent.vd_aux > (size_t) (endbuf - vstart))
10444 break;
10445
10446 vstart += ent.vd_aux;
10447
10448 if (vstart + sizeof (*eaux) > endbuf)
10449 break;
10450 eaux = (Elf_External_Verdaux *) vstart;
10451
10452 aux.vda_name = BYTE_GET (eaux->vda_name);
10453 aux.vda_next = BYTE_GET (eaux->vda_next);
10454
10455 if (VALID_DYNAMIC_NAME (aux.vda_name))
10456 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10457 else
10458 printf (_("Name index: %ld\n"), aux.vda_name);
10459
10460 isum = idx + ent.vd_aux;
10461
10462 for (j = 1; j < ent.vd_cnt; j++)
10463 {
10464 if (aux.vda_next < sizeof (*eaux)
10465 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10466 {
10467 warn (_("Invalid vda_next field of %lx\n"),
10468 aux.vda_next);
10469 j = ent.vd_cnt;
10470 break;
10471 }
10472 /* Check for overflow. */
10473 if (aux.vda_next > (size_t) (endbuf - vstart))
10474 break;
10475
10476 isum += aux.vda_next;
10477 vstart += aux.vda_next;
10478
10479 if (vstart + sizeof (*eaux) > endbuf)
10480 break;
10481 eaux = (Elf_External_Verdaux *) vstart;
10482
10483 aux.vda_name = BYTE_GET (eaux->vda_name);
10484 aux.vda_next = BYTE_GET (eaux->vda_next);
10485
10486 if (VALID_DYNAMIC_NAME (aux.vda_name))
10487 printf (_(" %#06lx: Parent %d: %s\n"),
10488 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10489 else
10490 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10491 isum, j, aux.vda_name);
10492 }
10493
10494 if (j < ent.vd_cnt)
10495 printf (_(" Version def aux past end of section\n"));
10496
10497 /* PR 17531:
10498 file: id:000001,src:000172+005151,op:splice,rep:2. */
10499 if (ent.vd_next < sizeof (*edef)
10500 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10501 {
10502 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10503 cnt = section->sh_info;
10504 break;
10505 }
10506 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10507 break;
10508
10509 idx += ent.vd_next;
10510 }
10511
10512 if (cnt < section->sh_info)
10513 printf (_(" Version definition past end of section\n"));
10514
10515 free (edefs);
10516 }
10517 break;
10518
10519 case SHT_GNU_verneed:
10520 {
10521 Elf_External_Verneed * eneed;
10522 unsigned long idx;
10523 unsigned long cnt;
10524 char * endbuf;
10525
10526 found = TRUE;
10527
10528 printf (ngettext ("\nVersion needs section '%s' "
10529 "contains %u entry:\n",
10530 "\nVersion needs section '%s' "
10531 "contains %u entries:\n",
10532 section->sh_info),
10533 printable_section_name (filedata, section), section->sh_info);
10534
10535 printf (_(" Addr: 0x"));
10536 printf_vma (section->sh_addr);
10537 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10538 (unsigned long) section->sh_offset, section->sh_link,
10539 printable_section_name_from_index (filedata, section->sh_link));
10540
10541 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10542 section->sh_offset, 1,
10543 section->sh_size,
10544 _("Version Needs section"));
10545 if (!eneed)
10546 break;
10547 endbuf = (char *) eneed + section->sh_size;
10548
10549 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10550 {
10551 Elf_External_Verneed * entry;
10552 Elf_Internal_Verneed ent;
10553 unsigned long isum;
10554 int j;
10555 char * vstart;
10556
10557 vstart = ((char *) eneed) + idx;
10558 if (vstart + sizeof (*entry) > endbuf)
10559 break;
10560
10561 entry = (Elf_External_Verneed *) vstart;
10562
10563 ent.vn_version = BYTE_GET (entry->vn_version);
10564 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10565 ent.vn_file = BYTE_GET (entry->vn_file);
10566 ent.vn_aux = BYTE_GET (entry->vn_aux);
10567 ent.vn_next = BYTE_GET (entry->vn_next);
10568
10569 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10570
10571 if (VALID_DYNAMIC_NAME (ent.vn_file))
10572 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10573 else
10574 printf (_(" File: %lx"), ent.vn_file);
10575
10576 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10577
10578 /* Check for overflow. */
10579 if (ent.vn_aux > (size_t) (endbuf - vstart))
10580 break;
10581 vstart += ent.vn_aux;
10582
10583 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10584 {
10585 Elf_External_Vernaux * eaux;
10586 Elf_Internal_Vernaux aux;
10587
10588 if (vstart + sizeof (*eaux) > endbuf)
10589 break;
10590 eaux = (Elf_External_Vernaux *) vstart;
10591
10592 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10593 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10594 aux.vna_other = BYTE_GET (eaux->vna_other);
10595 aux.vna_name = BYTE_GET (eaux->vna_name);
10596 aux.vna_next = BYTE_GET (eaux->vna_next);
10597
10598 if (VALID_DYNAMIC_NAME (aux.vna_name))
10599 printf (_(" %#06lx: Name: %s"),
10600 isum, GET_DYNAMIC_NAME (aux.vna_name));
10601 else
10602 printf (_(" %#06lx: Name index: %lx"),
10603 isum, aux.vna_name);
10604
10605 printf (_(" Flags: %s Version: %d\n"),
10606 get_ver_flags (aux.vna_flags), aux.vna_other);
10607
10608 if (aux.vna_next < sizeof (*eaux)
10609 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10610 {
10611 warn (_("Invalid vna_next field of %lx\n"),
10612 aux.vna_next);
10613 j = ent.vn_cnt;
10614 break;
10615 }
10616 /* Check for overflow. */
10617 if (aux.vna_next > (size_t) (endbuf - vstart))
10618 break;
10619 isum += aux.vna_next;
10620 vstart += aux.vna_next;
10621 }
10622
10623 if (j < ent.vn_cnt)
10624 warn (_("Missing Version Needs auxillary information\n"));
10625
10626 if (ent.vn_next < sizeof (*entry)
10627 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10628 {
10629 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10630 cnt = section->sh_info;
10631 break;
10632 }
10633 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10634 break;
10635 idx += ent.vn_next;
10636 }
10637
10638 if (cnt < section->sh_info)
10639 warn (_("Missing Version Needs information\n"));
10640
10641 free (eneed);
10642 }
10643 break;
10644
10645 case SHT_GNU_versym:
10646 {
10647 Elf_Internal_Shdr * link_section;
10648 size_t total;
10649 unsigned int cnt;
10650 unsigned char * edata;
10651 unsigned short * data;
10652 char * strtab;
10653 Elf_Internal_Sym * symbols;
10654 Elf_Internal_Shdr * string_sec;
10655 unsigned long num_syms;
10656 long off;
10657
10658 if (section->sh_link >= filedata->file_header.e_shnum)
10659 break;
10660
10661 link_section = filedata->section_headers + section->sh_link;
10662 total = section->sh_size / sizeof (Elf_External_Versym);
10663
10664 if (link_section->sh_link >= filedata->file_header.e_shnum)
10665 break;
10666
10667 found = TRUE;
10668
10669 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10670 if (symbols == NULL)
10671 break;
10672
10673 string_sec = filedata->section_headers + link_section->sh_link;
10674
10675 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10676 string_sec->sh_size,
10677 _("version string table"));
10678 if (!strtab)
10679 {
10680 free (symbols);
10681 break;
10682 }
10683
10684 printf (ngettext ("\nVersion symbols section '%s' "
10685 "contains %lu entry:\n",
10686 "\nVersion symbols section '%s' "
10687 "contains %lu entries:\n",
10688 total),
10689 printable_section_name (filedata, section), (unsigned long) total);
10690
10691 printf (_(" Addr: "));
10692 printf_vma (section->sh_addr);
10693 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10694 (unsigned long) section->sh_offset, section->sh_link,
10695 printable_section_name (filedata, link_section));
10696
10697 off = offset_from_vma (filedata,
10698 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10699 total * sizeof (short));
10700 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10701 sizeof (short),
10702 _("version symbol data"));
10703 if (!edata)
10704 {
10705 free (strtab);
10706 free (symbols);
10707 break;
10708 }
10709
10710 data = (short unsigned int *) cmalloc (total, sizeof (short));
10711
10712 for (cnt = total; cnt --;)
10713 data[cnt] = byte_get (edata + cnt * sizeof (short),
10714 sizeof (short));
10715
10716 free (edata);
10717
10718 for (cnt = 0; cnt < total; cnt += 4)
10719 {
10720 int j, nn;
10721 char *name;
10722 char *invalid = _("*invalid*");
10723
10724 printf (" %03x:", cnt);
10725
10726 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10727 switch (data[cnt + j])
10728 {
10729 case 0:
10730 fputs (_(" 0 (*local*) "), stdout);
10731 break;
10732
10733 case 1:
10734 fputs (_(" 1 (*global*) "), stdout);
10735 break;
10736
10737 default:
10738 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10739 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10740
10741 /* If this index value is greater than the size of the symbols
10742 array, break to avoid an out-of-bounds read. */
10743 if ((unsigned long)(cnt + j) >= num_syms)
10744 {
10745 warn (_("invalid index into symbol array\n"));
10746 break;
10747 }
10748
10749 name = NULL;
10750 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10751 {
10752 Elf_Internal_Verneed ivn;
10753 unsigned long offset;
10754
10755 offset = offset_from_vma
10756 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10757 sizeof (Elf_External_Verneed));
10758
10759 do
10760 {
10761 Elf_Internal_Vernaux ivna;
10762 Elf_External_Verneed evn;
10763 Elf_External_Vernaux evna;
10764 unsigned long a_off;
10765
10766 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10767 _("version need")) == NULL)
10768 break;
10769
10770 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10771 ivn.vn_next = BYTE_GET (evn.vn_next);
10772
10773 a_off = offset + ivn.vn_aux;
10774
10775 do
10776 {
10777 if (get_data (&evna, filedata, a_off, sizeof (evna),
10778 1, _("version need aux (2)")) == NULL)
10779 {
10780 ivna.vna_next = 0;
10781 ivna.vna_other = 0;
10782 }
10783 else
10784 {
10785 ivna.vna_next = BYTE_GET (evna.vna_next);
10786 ivna.vna_other = BYTE_GET (evna.vna_other);
10787 }
10788
10789 a_off += ivna.vna_next;
10790 }
10791 while (ivna.vna_other != data[cnt + j]
10792 && ivna.vna_next != 0);
10793
10794 if (ivna.vna_other == data[cnt + j])
10795 {
10796 ivna.vna_name = BYTE_GET (evna.vna_name);
10797
10798 if (ivna.vna_name >= string_sec->sh_size)
10799 name = invalid;
10800 else
10801 name = strtab + ivna.vna_name;
10802 break;
10803 }
10804
10805 offset += ivn.vn_next;
10806 }
10807 while (ivn.vn_next);
10808 }
10809
10810 if (data[cnt + j] != 0x8001
10811 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10812 {
10813 Elf_Internal_Verdef ivd;
10814 Elf_External_Verdef evd;
10815 unsigned long offset;
10816
10817 offset = offset_from_vma
10818 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10819 sizeof evd);
10820
10821 do
10822 {
10823 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10824 _("version def")) == NULL)
10825 {
10826 ivd.vd_next = 0;
10827 /* PR 17531: file: 046-1082287-0.004. */
10828 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10829 break;
10830 }
10831 else
10832 {
10833 ivd.vd_next = BYTE_GET (evd.vd_next);
10834 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10835 }
10836
10837 offset += ivd.vd_next;
10838 }
10839 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10840 && ivd.vd_next != 0);
10841
10842 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10843 {
10844 Elf_External_Verdaux evda;
10845 Elf_Internal_Verdaux ivda;
10846
10847 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10848
10849 if (get_data (&evda, filedata,
10850 offset - ivd.vd_next + ivd.vd_aux,
10851 sizeof (evda), 1,
10852 _("version def aux")) == NULL)
10853 break;
10854
10855 ivda.vda_name = BYTE_GET (evda.vda_name);
10856
10857 if (ivda.vda_name >= string_sec->sh_size)
10858 name = invalid;
10859 else if (name != NULL && name != invalid)
10860 name = _("*both*");
10861 else
10862 name = strtab + ivda.vda_name;
10863 }
10864 }
10865 if (name != NULL)
10866 nn += printf ("(%s%-*s",
10867 name,
10868 12 - (int) strlen (name),
10869 ")");
10870
10871 if (nn < 18)
10872 printf ("%*c", 18 - nn, ' ');
10873 }
10874
10875 putchar ('\n');
10876 }
10877
10878 free (data);
10879 free (strtab);
10880 free (symbols);
10881 }
10882 break;
10883
10884 default:
10885 break;
10886 }
10887 }
10888
10889 if (! found)
10890 printf (_("\nNo version information found in this file.\n"));
10891
10892 return TRUE;
10893}
10894
10895static const char *
10896get_symbol_binding (Filedata * filedata, unsigned int binding)
10897{
10898 static char buff[32];
10899
10900 switch (binding)
10901 {
10902 case STB_LOCAL: return "LOCAL";
10903 case STB_GLOBAL: return "GLOBAL";
10904 case STB_WEAK: return "WEAK";
10905 default:
10906 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10907 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10908 binding);
10909 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10910 {
10911 if (binding == STB_GNU_UNIQUE
10912 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10913 /* GNU is still using the default value 0. */
10914 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10915 return "UNIQUE";
10916 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10917 }
10918 else
10919 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10920 return buff;
10921 }
10922}
10923
10924static const char *
10925get_symbol_type (Filedata * filedata, unsigned int type)
10926{
10927 static char buff[32];
10928
10929 switch (type)
10930 {
10931 case STT_NOTYPE: return "NOTYPE";
10932 case STT_OBJECT: return "OBJECT";
10933 case STT_FUNC: return "FUNC";
10934 case STT_SECTION: return "SECTION";
10935 case STT_FILE: return "FILE";
10936 case STT_COMMON: return "COMMON";
10937 case STT_TLS: return "TLS";
10938 case STT_RELC: return "RELC";
10939 case STT_SRELC: return "SRELC";
10940 default:
10941 if (type >= STT_LOPROC && type <= STT_HIPROC)
10942 {
10943 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10944 return "THUMB_FUNC";
10945
10946 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10947 return "REGISTER";
10948
10949 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10950 return "PARISC_MILLI";
10951
10952 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10953 }
10954 else if (type >= STT_LOOS && type <= STT_HIOS)
10955 {
10956 if (filedata->file_header.e_machine == EM_PARISC)
10957 {
10958 if (type == STT_HP_OPAQUE)
10959 return "HP_OPAQUE";
10960 if (type == STT_HP_STUB)
10961 return "HP_STUB";
10962 }
10963
10964 if (type == STT_GNU_IFUNC
10965 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10966 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10967 /* GNU is still using the default value 0. */
10968 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10969 return "IFUNC";
10970
10971 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10972 }
10973 else
10974 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10975 return buff;
10976 }
10977}
10978
10979static const char *
10980get_symbol_visibility (unsigned int visibility)
10981{
10982 switch (visibility)
10983 {
10984 case STV_DEFAULT: return "DEFAULT";
10985 case STV_INTERNAL: return "INTERNAL";
10986 case STV_HIDDEN: return "HIDDEN";
10987 case STV_PROTECTED: return "PROTECTED";
10988 default:
10989 error (_("Unrecognized visibility value: %u"), visibility);
10990 return _("<unknown>");
10991 }
10992}
10993
10994static const char *
10995get_solaris_symbol_visibility (unsigned int visibility)
10996{
10997 switch (visibility)
10998 {
10999 case 4: return "EXPORTED";
11000 case 5: return "SINGLETON";
11001 case 6: return "ELIMINATE";
11002 default: return get_symbol_visibility (visibility);
11003 }
11004}
11005
11006static const char *
11007get_mips_symbol_other (unsigned int other)
11008{
11009 switch (other)
11010 {
11011 case STO_OPTIONAL: return "OPTIONAL";
11012 case STO_MIPS_PLT: return "MIPS PLT";
11013 case STO_MIPS_PIC: return "MIPS PIC";
11014 case STO_MICROMIPS: return "MICROMIPS";
11015 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11016 case STO_MIPS16: return "MIPS16";
11017 default: return NULL;
11018 }
11019}
11020
11021static const char *
11022get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11023{
11024 if (is_ia64_vms (filedata))
11025 {
11026 static char res[32];
11027
11028 res[0] = 0;
11029
11030 /* Function types is for images and .STB files only. */
11031 switch (filedata->file_header.e_type)
11032 {
11033 case ET_DYN:
11034 case ET_EXEC:
11035 switch (VMS_ST_FUNC_TYPE (other))
11036 {
11037 case VMS_SFT_CODE_ADDR:
11038 strcat (res, " CA");
11039 break;
11040 case VMS_SFT_SYMV_IDX:
11041 strcat (res, " VEC");
11042 break;
11043 case VMS_SFT_FD:
11044 strcat (res, " FD");
11045 break;
11046 case VMS_SFT_RESERVE:
11047 strcat (res, " RSV");
11048 break;
11049 default:
11050 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11051 VMS_ST_FUNC_TYPE (other));
11052 strcat (res, " <unknown>");
11053 break;
11054 }
11055 break;
11056 default:
11057 break;
11058 }
11059 switch (VMS_ST_LINKAGE (other))
11060 {
11061 case VMS_STL_IGNORE:
11062 strcat (res, " IGN");
11063 break;
11064 case VMS_STL_RESERVE:
11065 strcat (res, " RSV");
11066 break;
11067 case VMS_STL_STD:
11068 strcat (res, " STD");
11069 break;
11070 case VMS_STL_LNK:
11071 strcat (res, " LNK");
11072 break;
11073 default:
11074 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11075 VMS_ST_LINKAGE (other));
11076 strcat (res, " <unknown>");
11077 break;
11078 }
11079
11080 if (res[0] != 0)
11081 return res + 1;
11082 else
11083 return res;
11084 }
11085 return NULL;
11086}
11087
11088static const char *
11089get_ppc64_symbol_other (unsigned int other)
11090{
11091 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11092 return NULL;
11093
11094 other >>= STO_PPC64_LOCAL_BIT;
11095 if (other <= 6)
11096 {
11097 static char buf[32];
11098 if (other >= 2)
11099 other = ppc64_decode_local_entry (other);
11100 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11101 return buf;
11102 }
11103 return NULL;
11104}
11105
11106static const char *
11107get_symbol_other (Filedata * filedata, unsigned int other)
11108{
11109 const char * result = NULL;
11110 static char buff [32];
11111
11112 if (other == 0)
11113 return "";
11114
11115 switch (filedata->file_header.e_machine)
11116 {
11117 case EM_MIPS:
11118 result = get_mips_symbol_other (other);
11119 break;
11120 case EM_IA_64:
11121 result = get_ia64_symbol_other (filedata, other);
11122 break;
11123 case EM_PPC64:
11124 result = get_ppc64_symbol_other (other);
11125 break;
11126 default:
11127 result = NULL;
11128 break;
11129 }
11130
11131 if (result)
11132 return result;
11133
11134 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11135 return buff;
11136}
11137
11138static const char *
11139get_symbol_index_type (Filedata * filedata, unsigned int type)
11140{
11141 static char buff[32];
11142
11143 switch (type)
11144 {
11145 case SHN_UNDEF: return "UND";
11146 case SHN_ABS: return "ABS";
11147 case SHN_COMMON: return "COM";
11148 default:
11149 if (type == SHN_IA_64_ANSI_COMMON
11150 && filedata->file_header.e_machine == EM_IA_64
11151 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11152 return "ANSI_COM";
11153 else if ((filedata->file_header.e_machine == EM_X86_64
11154 || filedata->file_header.e_machine == EM_L1OM
11155 || filedata->file_header.e_machine == EM_K1OM)
11156 && type == SHN_X86_64_LCOMMON)
11157 return "LARGE_COM";
11158 else if ((type == SHN_MIPS_SCOMMON
11159 && filedata->file_header.e_machine == EM_MIPS)
11160 || (type == SHN_TIC6X_SCOMMON
11161 && filedata->file_header.e_machine == EM_TI_C6000))
11162 return "SCOM";
11163 else if (type == SHN_MIPS_SUNDEFINED
11164 && filedata->file_header.e_machine == EM_MIPS)
11165 return "SUND";
11166 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11167 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11168 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11169 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11170 else if (type >= SHN_LORESERVE)
11171 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11172 else if (type >= filedata->file_header.e_shnum)
11173 sprintf (buff, _("bad section index[%3d]"), type);
11174 else
11175 sprintf (buff, "%3d", type);
11176 break;
11177 }
11178
11179 return buff;
11180}
11181
11182static bfd_vma *
11183get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11184{
11185 unsigned char * e_data;
11186 bfd_vma * i_data;
11187
11188 /* If the size_t type is smaller than the bfd_size_type, eg because
11189 you are building a 32-bit tool on a 64-bit host, then make sure
11190 that when (number) is cast to (size_t) no information is lost. */
11191 if (sizeof (size_t) < sizeof (bfd_size_type)
11192 && (bfd_size_type) ((size_t) number) != number)
11193 {
11194 error (_("Size truncation prevents reading %s elements of size %u\n"),
11195 bfd_vmatoa ("u", number), ent_size);
11196 return NULL;
11197 }
11198
11199 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11200 attempting to allocate memory when the read is bound to fail. */
11201 if (ent_size * number > filedata->file_size)
11202 {
11203 error (_("Invalid number of dynamic entries: %s\n"),
11204 bfd_vmatoa ("u", number));
11205 return NULL;
11206 }
11207
11208 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11209 if (e_data == NULL)
11210 {
11211 error (_("Out of memory reading %s dynamic entries\n"),
11212 bfd_vmatoa ("u", number));
11213 return NULL;
11214 }
11215
11216 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11217 {
11218 error (_("Unable to read in %s bytes of dynamic data\n"),
11219 bfd_vmatoa ("u", number * ent_size));
11220 free (e_data);
11221 return NULL;
11222 }
11223
11224 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11225 if (i_data == NULL)
11226 {
11227 error (_("Out of memory allocating space for %s dynamic entries\n"),
11228 bfd_vmatoa ("u", number));
11229 free (e_data);
11230 return NULL;
11231 }
11232
11233 while (number--)
11234 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11235
11236 free (e_data);
11237
11238 return i_data;
11239}
11240
11241static void
11242print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11243{
11244 Elf_Internal_Sym * psym;
11245 int n;
11246
11247 n = print_vma (si, DEC_5);
11248 if (n < 5)
11249 fputs (&" "[n], stdout);
11250 printf (" %3lu: ", hn);
11251
11252 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11253 {
11254 printf (_("<No info available for dynamic symbol number %lu>\n"),
11255 (unsigned long) si);
11256 return;
11257 }
11258
11259 psym = dynamic_symbols + si;
11260 print_vma (psym->st_value, LONG_HEX);
11261 putchar (' ');
11262 print_vma (psym->st_size, DEC_5);
11263
11264 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11265 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11266
11267 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11268 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11269 else
11270 {
11271 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11272
11273 printf (" %-7s", get_symbol_visibility (vis));
11274 /* Check to see if any other bits in the st_other field are set.
11275 Note - displaying this information disrupts the layout of the
11276 table being generated, but for the moment this case is very
11277 rare. */
11278 if (psym->st_other ^ vis)
11279 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11280 }
11281
11282 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11283 if (VALID_DYNAMIC_NAME (psym->st_name))
11284 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11285 else
11286 printf (_(" <corrupt: %14ld>"), psym->st_name);
11287 putchar ('\n');
11288}
11289
11290static const char *
11291get_symbol_version_string (Filedata * filedata,
11292 bfd_boolean is_dynsym,
11293 const char * strtab,
11294 unsigned long int strtab_size,
11295 unsigned int si,
11296 Elf_Internal_Sym * psym,
11297 enum versioned_symbol_info * sym_info,
11298 unsigned short * vna_other)
11299{
11300 unsigned char data[2];
11301 unsigned short vers_data;
11302 unsigned long offset;
11303
11304 if (!is_dynsym
11305 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11306 return NULL;
11307
11308 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11309 sizeof data + si * sizeof (vers_data));
11310
11311 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11312 sizeof (data), 1, _("version data")) == NULL)
11313 return NULL;
11314
11315 vers_data = byte_get (data, 2);
11316
11317 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11318 return NULL;
11319
11320 /* Usually we'd only see verdef for defined symbols, and verneed for
11321 undefined symbols. However, symbols defined by the linker in
11322 .dynbss for variables copied from a shared library in order to
11323 avoid text relocations are defined yet have verneed. We could
11324 use a heuristic to detect the special case, for example, check
11325 for verneed first on symbols defined in SHT_NOBITS sections, but
11326 it is simpler and more reliable to just look for both verdef and
11327 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11328
11329 if (psym->st_shndx != SHN_UNDEF
11330 && vers_data != 0x8001
11331 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11332 {
11333 Elf_Internal_Verdef ivd;
11334 Elf_Internal_Verdaux ivda;
11335 Elf_External_Verdaux evda;
11336 unsigned long off;
11337
11338 off = offset_from_vma (filedata,
11339 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11340 sizeof (Elf_External_Verdef));
11341
11342 do
11343 {
11344 Elf_External_Verdef evd;
11345
11346 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11347 _("version def")) == NULL)
11348 {
11349 ivd.vd_ndx = 0;
11350 ivd.vd_aux = 0;
11351 ivd.vd_next = 0;
11352 ivd.vd_flags = 0;
11353 }
11354 else
11355 {
11356 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11357 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11358 ivd.vd_next = BYTE_GET (evd.vd_next);
11359 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11360 }
11361
11362 off += ivd.vd_next;
11363 }
11364 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11365
11366 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11367 {
11368 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11369 return NULL;
11370
11371 off -= ivd.vd_next;
11372 off += ivd.vd_aux;
11373
11374 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11375 _("version def aux")) != NULL)
11376 {
11377 ivda.vda_name = BYTE_GET (evda.vda_name);
11378
11379 if (psym->st_name != ivda.vda_name)
11380 {
11381 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11382 ? symbol_hidden : symbol_public);
11383 return (ivda.vda_name < strtab_size
11384 ? strtab + ivda.vda_name : _("<corrupt>"));
11385 }
11386 }
11387 }
11388 }
11389
11390 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11391 {
11392 Elf_External_Verneed evn;
11393 Elf_Internal_Verneed ivn;
11394 Elf_Internal_Vernaux ivna;
11395
11396 offset = offset_from_vma (filedata,
11397 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11398 sizeof evn);
11399 do
11400 {
11401 unsigned long vna_off;
11402
11403 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11404 _("version need")) == NULL)
11405 {
11406 ivna.vna_next = 0;
11407 ivna.vna_other = 0;
11408 ivna.vna_name = 0;
11409 break;
11410 }
11411
11412 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11413 ivn.vn_next = BYTE_GET (evn.vn_next);
11414
11415 vna_off = offset + ivn.vn_aux;
11416
11417 do
11418 {
11419 Elf_External_Vernaux evna;
11420
11421 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11422 _("version need aux (3)")) == NULL)
11423 {
11424 ivna.vna_next = 0;
11425 ivna.vna_other = 0;
11426 ivna.vna_name = 0;
11427 }
11428 else
11429 {
11430 ivna.vna_other = BYTE_GET (evna.vna_other);
11431 ivna.vna_next = BYTE_GET (evna.vna_next);
11432 ivna.vna_name = BYTE_GET (evna.vna_name);
11433 }
11434
11435 vna_off += ivna.vna_next;
11436 }
11437 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11438
11439 if (ivna.vna_other == vers_data)
11440 break;
11441
11442 offset += ivn.vn_next;
11443 }
11444 while (ivn.vn_next != 0);
11445
11446 if (ivna.vna_other == vers_data)
11447 {
11448 *sym_info = symbol_undefined;
11449 *vna_other = ivna.vna_other;
11450 return (ivna.vna_name < strtab_size
11451 ? strtab + ivna.vna_name : _("<corrupt>"));
11452 }
11453 }
11454 return NULL;
11455}
11456
11457/* Dump the symbol table. */
11458static bfd_boolean
11459process_symbol_table (Filedata * filedata)
11460{
11461 Elf_Internal_Shdr * section;
11462 bfd_size_type nbuckets = 0;
11463 bfd_size_type nchains = 0;
11464 bfd_vma * buckets = NULL;
11465 bfd_vma * chains = NULL;
11466 bfd_vma ngnubuckets = 0;
11467 bfd_vma * gnubuckets = NULL;
11468 bfd_vma * gnuchains = NULL;
11469 bfd_vma gnusymidx = 0;
11470 bfd_size_type ngnuchains = 0;
11471
11472 if (!do_syms && !do_dyn_syms && !do_histogram)
11473 return TRUE;
11474
11475 if (dynamic_info[DT_HASH]
11476 && (do_histogram
11477 || (do_using_dynamic
11478 && !do_dyn_syms
11479 && dynamic_strings != NULL)))
11480 {
11481 unsigned char nb[8];
11482 unsigned char nc[8];
11483 unsigned int hash_ent_size = 4;
11484
11485 if ((filedata->file_header.e_machine == EM_ALPHA
11486 || filedata->file_header.e_machine == EM_S390
11487 || filedata->file_header.e_machine == EM_S390_OLD)
11488 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11489 hash_ent_size = 8;
11490
11491 if (fseek (filedata->handle,
11492 (archive_file_offset
11493 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11494 sizeof nb + sizeof nc)),
11495 SEEK_SET))
11496 {
11497 error (_("Unable to seek to start of dynamic information\n"));
11498 goto no_hash;
11499 }
11500
11501 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11502 {
11503 error (_("Failed to read in number of buckets\n"));
11504 goto no_hash;
11505 }
11506
11507 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11508 {
11509 error (_("Failed to read in number of chains\n"));
11510 goto no_hash;
11511 }
11512
11513 nbuckets = byte_get (nb, hash_ent_size);
11514 nchains = byte_get (nc, hash_ent_size);
11515
11516 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11517 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11518
11519 no_hash:
11520 if (buckets == NULL || chains == NULL)
11521 {
11522 if (do_using_dynamic)
11523 return FALSE;
11524 free (buckets);
11525 free (chains);
11526 buckets = NULL;
11527 chains = NULL;
11528 nbuckets = 0;
11529 nchains = 0;
11530 }
11531 }
11532
11533 if (dynamic_info_DT_GNU_HASH
11534 && (do_histogram
11535 || (do_using_dynamic
11536 && !do_dyn_syms
11537 && dynamic_strings != NULL)))
11538 {
11539 unsigned char nb[16];
11540 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11541 bfd_vma buckets_vma;
11542
11543 if (fseek (filedata->handle,
11544 (archive_file_offset
11545 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11546 sizeof nb)),
11547 SEEK_SET))
11548 {
11549 error (_("Unable to seek to start of dynamic information\n"));
11550 goto no_gnu_hash;
11551 }
11552
11553 if (fread (nb, 16, 1, filedata->handle) != 1)
11554 {
11555 error (_("Failed to read in number of buckets\n"));
11556 goto no_gnu_hash;
11557 }
11558
11559 ngnubuckets = byte_get (nb, 4);
11560 gnusymidx = byte_get (nb + 4, 4);
11561 bitmaskwords = byte_get (nb + 8, 4);
11562 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11563 if (is_32bit_elf)
11564 buckets_vma += bitmaskwords * 4;
11565 else
11566 buckets_vma += bitmaskwords * 8;
11567
11568 if (fseek (filedata->handle,
11569 (archive_file_offset
11570 + offset_from_vma (filedata, buckets_vma, 4)),
11571 SEEK_SET))
11572 {
11573 error (_("Unable to seek to start of dynamic information\n"));
11574 goto no_gnu_hash;
11575 }
11576
11577 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11578
11579 if (gnubuckets == NULL)
11580 goto no_gnu_hash;
11581
11582 for (i = 0; i < ngnubuckets; i++)
11583 if (gnubuckets[i] != 0)
11584 {
11585 if (gnubuckets[i] < gnusymidx)
11586 return FALSE;
11587
11588 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11589 maxchain = gnubuckets[i];
11590 }
11591
11592 if (maxchain == 0xffffffff)
11593 goto no_gnu_hash;
11594
11595 maxchain -= gnusymidx;
11596
11597 if (fseek (filedata->handle,
11598 (archive_file_offset
11599 + offset_from_vma (filedata, buckets_vma
11600 + 4 * (ngnubuckets + maxchain), 4)),
11601 SEEK_SET))
11602 {
11603 error (_("Unable to seek to start of dynamic information\n"));
11604 goto no_gnu_hash;
11605 }
11606
11607 do
11608 {
11609 if (fread (nb, 4, 1, filedata->handle) != 1)
11610 {
11611 error (_("Failed to determine last chain length\n"));
11612 goto no_gnu_hash;
11613 }
11614
11615 if (maxchain + 1 == 0)
11616 goto no_gnu_hash;
11617
11618 ++maxchain;
11619 }
11620 while ((byte_get (nb, 4) & 1) == 0);
11621
11622 if (fseek (filedata->handle,
11623 (archive_file_offset
11624 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11625 SEEK_SET))
11626 {
11627 error (_("Unable to seek to start of dynamic information\n"));
11628 goto no_gnu_hash;
11629 }
11630
11631 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11632 ngnuchains = maxchain;
11633
11634 no_gnu_hash:
11635 if (gnuchains == NULL)
11636 {
11637 free (gnubuckets);
11638 gnubuckets = NULL;
11639 ngnubuckets = 0;
11640 if (do_using_dynamic)
11641 return FALSE;
11642 }
11643 }
11644
11645 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11646 && do_syms
11647 && do_using_dynamic
11648 && dynamic_strings != NULL
11649 && dynamic_symbols != NULL)
11650 {
11651 unsigned long hn;
11652
11653 if (dynamic_info[DT_HASH])
11654 {
11655 bfd_vma si;
11656 char *visited;
11657
11658 printf (_("\nSymbol table for image:\n"));
11659 if (is_32bit_elf)
11660 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11661 else
11662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11663
11664 visited = xcmalloc (nchains, 1);
11665 memset (visited, 0, nchains);
11666 for (hn = 0; hn < nbuckets; hn++)
11667 {
11668 for (si = buckets[hn]; si > 0; si = chains[si])
11669 {
11670 print_dynamic_symbol (filedata, si, hn);
11671 if (si >= nchains || visited[si])
11672 {
11673 error (_("histogram chain is corrupt\n"));
11674 break;
11675 }
11676 visited[si] = 1;
11677 }
11678 }
11679 free (visited);
11680 }
11681
11682 if (dynamic_info_DT_GNU_HASH)
11683 {
11684 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11685 if (is_32bit_elf)
11686 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11687 else
11688 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11689
11690 for (hn = 0; hn < ngnubuckets; ++hn)
11691 if (gnubuckets[hn] != 0)
11692 {
11693 bfd_vma si = gnubuckets[hn];
11694 bfd_vma off = si - gnusymidx;
11695
11696 do
11697 {
11698 print_dynamic_symbol (filedata, si, hn);
11699 si++;
11700 }
11701 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11702 }
11703 }
11704 }
11705 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11706 && filedata->section_headers != NULL)
11707 {
11708 unsigned int i;
11709
11710 for (i = 0, section = filedata->section_headers;
11711 i < filedata->file_header.e_shnum;
11712 i++, section++)
11713 {
11714 unsigned int si;
11715 char * strtab = NULL;
11716 unsigned long int strtab_size = 0;
11717 Elf_Internal_Sym * symtab;
11718 Elf_Internal_Sym * psym;
11719 unsigned long num_syms;
11720
11721 if ((section->sh_type != SHT_SYMTAB
11722 && section->sh_type != SHT_DYNSYM)
11723 || (!do_syms
11724 && section->sh_type == SHT_SYMTAB))
11725 continue;
11726
11727 if (section->sh_entsize == 0)
11728 {
11729 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11730 printable_section_name (filedata, section));
11731 continue;
11732 }
11733
11734 num_syms = section->sh_size / section->sh_entsize;
11735 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11736 "\nSymbol table '%s' contains %lu entries:\n",
11737 num_syms),
11738 printable_section_name (filedata, section),
11739 num_syms);
11740
11741 if (is_32bit_elf)
11742 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11743 else
11744 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11745
11746 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11747 if (symtab == NULL)
11748 continue;
11749
11750 if (section->sh_link == filedata->file_header.e_shstrndx)
11751 {
11752 strtab = filedata->string_table;
11753 strtab_size = filedata->string_table_length;
11754 }
11755 else if (section->sh_link < filedata->file_header.e_shnum)
11756 {
11757 Elf_Internal_Shdr * string_sec;
11758
11759 string_sec = filedata->section_headers + section->sh_link;
11760
11761 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11762 1, string_sec->sh_size,
11763 _("string table"));
11764 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11765 }
11766
11767 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11768 {
11769 const char *version_string;
11770 enum versioned_symbol_info sym_info;
11771 unsigned short vna_other;
11772
11773 printf ("%6d: ", si);
11774 print_vma (psym->st_value, LONG_HEX);
11775 putchar (' ');
11776 print_vma (psym->st_size, DEC_5);
11777 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11778 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11779 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11780 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11781 else
11782 {
11783 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11784
11785 printf (" %-7s", get_symbol_visibility (vis));
11786 /* Check to see if any other bits in the st_other field are set.
11787 Note - displaying this information disrupts the layout of the
11788 table being generated, but for the moment this case is very rare. */
11789 if (psym->st_other ^ vis)
11790 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11791 }
11792 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11793 print_symbol (25, psym->st_name < strtab_size
11794 ? strtab + psym->st_name : _("<corrupt>"));
11795
11796 version_string
11797 = get_symbol_version_string (filedata,
11798 section->sh_type == SHT_DYNSYM,
11799 strtab, strtab_size, si,
11800 psym, &sym_info, &vna_other);
11801 if (version_string)
11802 {
11803 if (sym_info == symbol_undefined)
11804 printf ("@%s (%d)", version_string, vna_other);
11805 else
11806 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11807 version_string);
11808 }
11809
11810 putchar ('\n');
11811
11812 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11813 && si >= section->sh_info
11814 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11815 && filedata->file_header.e_machine != EM_MIPS
11816 /* Solaris binaries have been found to violate this requirement as
11817 well. Not sure if this is a bug or an ABI requirement. */
11818 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11819 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11820 si, printable_section_name (filedata, section), section->sh_info);
11821 }
11822
11823 free (symtab);
11824 if (strtab != filedata->string_table)
11825 free (strtab);
11826 }
11827 }
11828 else if (do_syms)
11829 printf
11830 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11831
11832 if (do_histogram && buckets != NULL)
11833 {
11834 unsigned long * lengths;
11835 unsigned long * counts;
11836 unsigned long hn;
11837 bfd_vma si;
11838 unsigned long maxlength = 0;
11839 unsigned long nzero_counts = 0;
11840 unsigned long nsyms = 0;
11841 char *visited;
11842
11843 printf (ngettext ("\nHistogram for bucket list length "
11844 "(total of %lu bucket):\n",
11845 "\nHistogram for bucket list length "
11846 "(total of %lu buckets):\n",
11847 (unsigned long) nbuckets),
11848 (unsigned long) nbuckets);
11849
11850 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11851 if (lengths == NULL)
11852 {
11853 error (_("Out of memory allocating space for histogram buckets\n"));
11854 return FALSE;
11855 }
11856 visited = xcmalloc (nchains, 1);
11857 memset (visited, 0, nchains);
11858
11859 printf (_(" Length Number %% of total Coverage\n"));
11860 for (hn = 0; hn < nbuckets; ++hn)
11861 {
11862 for (si = buckets[hn]; si > 0; si = chains[si])
11863 {
11864 ++nsyms;
11865 if (maxlength < ++lengths[hn])
11866 ++maxlength;
11867 if (si >= nchains || visited[si])
11868 {
11869 error (_("histogram chain is corrupt\n"));
11870 break;
11871 }
11872 visited[si] = 1;
11873 }
11874 }
11875 free (visited);
11876
11877 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11878 if (counts == NULL)
11879 {
11880 free (lengths);
11881 error (_("Out of memory allocating space for histogram counts\n"));
11882 return FALSE;
11883 }
11884
11885 for (hn = 0; hn < nbuckets; ++hn)
11886 ++counts[lengths[hn]];
11887
11888 if (nbuckets > 0)
11889 {
11890 unsigned long i;
11891 printf (" 0 %-10lu (%5.1f%%)\n",
11892 counts[0], (counts[0] * 100.0) / nbuckets);
11893 for (i = 1; i <= maxlength; ++i)
11894 {
11895 nzero_counts += counts[i] * i;
11896 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11897 i, counts[i], (counts[i] * 100.0) / nbuckets,
11898 (nzero_counts * 100.0) / nsyms);
11899 }
11900 }
11901
11902 free (counts);
11903 free (lengths);
11904 }
11905
11906 if (buckets != NULL)
11907 {
11908 free (buckets);
11909 free (chains);
11910 }
11911
11912 if (do_histogram && gnubuckets != NULL)
11913 {
11914 unsigned long * lengths;
11915 unsigned long * counts;
11916 unsigned long hn;
11917 unsigned long maxlength = 0;
11918 unsigned long nzero_counts = 0;
11919 unsigned long nsyms = 0;
11920
11921 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11922 "(total of %lu bucket):\n",
11923 "\nHistogram for `.gnu.hash' bucket list length "
11924 "(total of %lu buckets):\n",
11925 (unsigned long) ngnubuckets),
11926 (unsigned long) ngnubuckets);
11927
11928 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11929 if (lengths == NULL)
11930 {
11931 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11932 return FALSE;
11933 }
11934
11935 printf (_(" Length Number %% of total Coverage\n"));
11936
11937 for (hn = 0; hn < ngnubuckets; ++hn)
11938 if (gnubuckets[hn] != 0)
11939 {
11940 bfd_vma off, length = 1;
11941
11942 for (off = gnubuckets[hn] - gnusymidx;
11943 /* PR 17531 file: 010-77222-0.004. */
11944 off < ngnuchains && (gnuchains[off] & 1) == 0;
11945 ++off)
11946 ++length;
11947 lengths[hn] = length;
11948 if (length > maxlength)
11949 maxlength = length;
11950 nsyms += length;
11951 }
11952
11953 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11954 if (counts == NULL)
11955 {
11956 free (lengths);
11957 error (_("Out of memory allocating space for gnu histogram counts\n"));
11958 return FALSE;
11959 }
11960
11961 for (hn = 0; hn < ngnubuckets; ++hn)
11962 ++counts[lengths[hn]];
11963
11964 if (ngnubuckets > 0)
11965 {
11966 unsigned long j;
11967 printf (" 0 %-10lu (%5.1f%%)\n",
11968 counts[0], (counts[0] * 100.0) / ngnubuckets);
11969 for (j = 1; j <= maxlength; ++j)
11970 {
11971 nzero_counts += counts[j] * j;
11972 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11973 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11974 (nzero_counts * 100.0) / nsyms);
11975 }
11976 }
11977
11978 free (counts);
11979 free (lengths);
11980 free (gnubuckets);
11981 free (gnuchains);
11982 }
11983
11984 return TRUE;
11985}
11986
11987static bfd_boolean
11988process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11989{
11990 unsigned int i;
11991
11992 if (dynamic_syminfo == NULL
11993 || !do_dynamic)
11994 /* No syminfo, this is ok. */
11995 return TRUE;
11996
11997 /* There better should be a dynamic symbol section. */
11998 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11999 return FALSE;
12000
12001 if (dynamic_addr)
12002 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12003 "contains %d entry:\n",
12004 "\nDynamic info segment at offset 0x%lx "
12005 "contains %d entries:\n",
12006 dynamic_syminfo_nent),
12007 dynamic_syminfo_offset, dynamic_syminfo_nent);
12008
12009 printf (_(" Num: Name BoundTo Flags\n"));
12010 for (i = 0; i < dynamic_syminfo_nent; ++i)
12011 {
12012 unsigned short int flags = dynamic_syminfo[i].si_flags;
12013
12014 printf ("%4d: ", i);
12015 if (i >= num_dynamic_syms)
12016 printf (_("<corrupt index>"));
12017 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12018 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12019 else
12020 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12021 putchar (' ');
12022
12023 switch (dynamic_syminfo[i].si_boundto)
12024 {
12025 case SYMINFO_BT_SELF:
12026 fputs ("SELF ", stdout);
12027 break;
12028 case SYMINFO_BT_PARENT:
12029 fputs ("PARENT ", stdout);
12030 break;
12031 default:
12032 if (dynamic_syminfo[i].si_boundto > 0
12033 && dynamic_syminfo[i].si_boundto < dynamic_nent
12034 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12035 {
12036 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12037 putchar (' ' );
12038 }
12039 else
12040 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12041 break;
12042 }
12043
12044 if (flags & SYMINFO_FLG_DIRECT)
12045 printf (" DIRECT");
12046 if (flags & SYMINFO_FLG_PASSTHRU)
12047 printf (" PASSTHRU");
12048 if (flags & SYMINFO_FLG_COPY)
12049 printf (" COPY");
12050 if (flags & SYMINFO_FLG_LAZYLOAD)
12051 printf (" LAZYLOAD");
12052
12053 puts ("");
12054 }
12055
12056 return TRUE;
12057}
12058
12059#define IN_RANGE(START,END,ADDR,OFF) \
12060 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12061
12062/* Check to see if the given reloc needs to be handled in a target specific
12063 manner. If so then process the reloc and return TRUE otherwise return
12064 FALSE.
12065
12066 If called with reloc == NULL, then this is a signal that reloc processing
12067 for the current section has finished, and any saved state should be
12068 discarded. */
12069
12070static bfd_boolean
12071target_specific_reloc_handling (Filedata * filedata,
12072 Elf_Internal_Rela * reloc,
12073 unsigned char * start,
12074 unsigned char * end,
12075 Elf_Internal_Sym * symtab,
12076 unsigned long num_syms)
12077{
12078 unsigned int reloc_type = 0;
12079 unsigned long sym_index = 0;
12080
12081 if (reloc)
12082 {
12083 reloc_type = get_reloc_type (filedata, reloc->r_info);
12084 sym_index = get_reloc_symindex (reloc->r_info);
12085 }
12086
12087 switch (filedata->file_header.e_machine)
12088 {
12089 case EM_MSP430:
12090 case EM_MSP430_OLD:
12091 {
12092 static Elf_Internal_Sym * saved_sym = NULL;
12093
12094 if (reloc == NULL)
12095 {
12096 saved_sym = NULL;
12097 return TRUE;
12098 }
12099
12100 switch (reloc_type)
12101 {
12102 case 10: /* R_MSP430_SYM_DIFF */
12103 if (uses_msp430x_relocs (filedata))
12104 break;
12105 /* Fall through. */
12106 case 21: /* R_MSP430X_SYM_DIFF */
12107 /* PR 21139. */
12108 if (sym_index >= num_syms)
12109 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12110 sym_index);
12111 else
12112 saved_sym = symtab + sym_index;
12113 return TRUE;
12114
12115 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12116 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12117 goto handle_sym_diff;
12118
12119 case 5: /* R_MSP430_16_BYTE */
12120 case 9: /* R_MSP430_8 */
12121 if (uses_msp430x_relocs (filedata))
12122 break;
12123 goto handle_sym_diff;
12124
12125 case 2: /* R_MSP430_ABS16 */
12126 case 15: /* R_MSP430X_ABS16 */
12127 if (! uses_msp430x_relocs (filedata))
12128 break;
12129 goto handle_sym_diff;
12130
12131 handle_sym_diff:
12132 if (saved_sym != NULL)
12133 {
12134 int reloc_size = reloc_type == 1 ? 4 : 2;
12135 bfd_vma value;
12136
12137 if (sym_index >= num_syms)
12138 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12139 sym_index);
12140 else
12141 {
12142 value = reloc->r_addend + (symtab[sym_index].st_value
12143 - saved_sym->st_value);
12144
12145 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12146 byte_put (start + reloc->r_offset, value, reloc_size);
12147 else
12148 /* PR 21137 */
12149 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12150 (long) reloc->r_offset);
12151 }
12152
12153 saved_sym = NULL;
12154 return TRUE;
12155 }
12156 break;
12157
12158 default:
12159 if (saved_sym != NULL)
12160 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12161 break;
12162 }
12163 break;
12164 }
12165
12166 case EM_MN10300:
12167 case EM_CYGNUS_MN10300:
12168 {
12169 static Elf_Internal_Sym * saved_sym = NULL;
12170
12171 if (reloc == NULL)
12172 {
12173 saved_sym = NULL;
12174 return TRUE;
12175 }
12176
12177 switch (reloc_type)
12178 {
12179 case 34: /* R_MN10300_ALIGN */
12180 return TRUE;
12181 case 33: /* R_MN10300_SYM_DIFF */
12182 if (sym_index >= num_syms)
12183 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12184 sym_index);
12185 else
12186 saved_sym = symtab + sym_index;
12187 return TRUE;
12188
12189 case 1: /* R_MN10300_32 */
12190 case 2: /* R_MN10300_16 */
12191 if (saved_sym != NULL)
12192 {
12193 int reloc_size = reloc_type == 1 ? 4 : 2;
12194 bfd_vma value;
12195
12196 if (sym_index >= num_syms)
12197 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12198 sym_index);
12199 else
12200 {
12201 value = reloc->r_addend + (symtab[sym_index].st_value
12202 - saved_sym->st_value);
12203
12204 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12205 byte_put (start + reloc->r_offset, value, reloc_size);
12206 else
12207 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12208 (long) reloc->r_offset);
12209 }
12210
12211 saved_sym = NULL;
12212 return TRUE;
12213 }
12214 break;
12215 default:
12216 if (saved_sym != NULL)
12217 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12218 break;
12219 }
12220 break;
12221 }
12222
12223 case EM_RL78:
12224 {
12225 static bfd_vma saved_sym1 = 0;
12226 static bfd_vma saved_sym2 = 0;
12227 static bfd_vma value;
12228
12229 if (reloc == NULL)
12230 {
12231 saved_sym1 = saved_sym2 = 0;
12232 return TRUE;
12233 }
12234
12235 switch (reloc_type)
12236 {
12237 case 0x80: /* R_RL78_SYM. */
12238 saved_sym1 = saved_sym2;
12239 if (sym_index >= num_syms)
12240 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12241 sym_index);
12242 else
12243 {
12244 saved_sym2 = symtab[sym_index].st_value;
12245 saved_sym2 += reloc->r_addend;
12246 }
12247 return TRUE;
12248
12249 case 0x83: /* R_RL78_OPsub. */
12250 value = saved_sym1 - saved_sym2;
12251 saved_sym2 = saved_sym1 = 0;
12252 return TRUE;
12253 break;
12254
12255 case 0x41: /* R_RL78_ABS32. */
12256 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12257 byte_put (start + reloc->r_offset, value, 4);
12258 else
12259 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12260 (long) reloc->r_offset);
12261 value = 0;
12262 return TRUE;
12263
12264 case 0x43: /* R_RL78_ABS16. */
12265 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12266 byte_put (start + reloc->r_offset, value, 2);
12267 else
12268 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12269 (long) reloc->r_offset);
12270 value = 0;
12271 return TRUE;
12272
12273 default:
12274 break;
12275 }
12276 break;
12277 }
12278 }
12279
12280 return FALSE;
12281}
12282
12283/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12284 DWARF debug sections. This is a target specific test. Note - we do not
12285 go through the whole including-target-headers-multiple-times route, (as
12286 we have already done with <elf/h8.h>) because this would become very
12287 messy and even then this function would have to contain target specific
12288 information (the names of the relocs instead of their numeric values).
12289 FIXME: This is not the correct way to solve this problem. The proper way
12290 is to have target specific reloc sizing and typing functions created by
12291 the reloc-macros.h header, in the same way that it already creates the
12292 reloc naming functions. */
12293
12294static bfd_boolean
12295is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12296{
12297 /* Please keep this table alpha-sorted for ease of visual lookup. */
12298 switch (filedata->file_header.e_machine)
12299 {
12300 case EM_386:
12301 case EM_IAMCU:
12302 return reloc_type == 1; /* R_386_32. */
12303 case EM_68K:
12304 return reloc_type == 1; /* R_68K_32. */
12305 case EM_860:
12306 return reloc_type == 1; /* R_860_32. */
12307 case EM_960:
12308 return reloc_type == 2; /* R_960_32. */
12309 case EM_AARCH64:
12310 return (reloc_type == 258
12311 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12312 case EM_ADAPTEVA_EPIPHANY:
12313 return reloc_type == 3;
12314 case EM_ALPHA:
12315 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12316 case EM_ARC:
12317 return reloc_type == 1; /* R_ARC_32. */
12318 case EM_ARC_COMPACT:
12319 case EM_ARC_COMPACT2:
12320 return reloc_type == 4; /* R_ARC_32. */
12321 case EM_ARM:
12322 return reloc_type == 2; /* R_ARM_ABS32 */
12323 case EM_AVR_OLD:
12324 case EM_AVR:
12325 return reloc_type == 1;
12326 case EM_BLACKFIN:
12327 return reloc_type == 0x12; /* R_byte4_data. */
12328 case EM_CRIS:
12329 return reloc_type == 3; /* R_CRIS_32. */
12330 case EM_CR16:
12331 return reloc_type == 3; /* R_CR16_NUM32. */
12332 case EM_CRX:
12333 return reloc_type == 15; /* R_CRX_NUM32. */
12334 case EM_CSKY:
12335 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12336 case EM_CYGNUS_FRV:
12337 return reloc_type == 1;
12338 case EM_CYGNUS_D10V:
12339 case EM_D10V:
12340 return reloc_type == 6; /* R_D10V_32. */
12341 case EM_CYGNUS_D30V:
12342 case EM_D30V:
12343 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12344 case EM_DLX:
12345 return reloc_type == 3; /* R_DLX_RELOC_32. */
12346 case EM_CYGNUS_FR30:
12347 case EM_FR30:
12348 return reloc_type == 3; /* R_FR30_32. */
12349 case EM_FT32:
12350 return reloc_type == 1; /* R_FT32_32. */
12351 case EM_H8S:
12352 case EM_H8_300:
12353 case EM_H8_300H:
12354 return reloc_type == 1; /* R_H8_DIR32. */
12355 case EM_IA_64:
12356 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12357 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12358 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12359 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12360 case EM_IP2K_OLD:
12361 case EM_IP2K:
12362 return reloc_type == 2; /* R_IP2K_32. */
12363 case EM_IQ2000:
12364 return reloc_type == 2; /* R_IQ2000_32. */
12365 case EM_LATTICEMICO32:
12366 return reloc_type == 3; /* R_LM32_32. */
12367 case EM_M32C_OLD:
12368 case EM_M32C:
12369 return reloc_type == 3; /* R_M32C_32. */
12370 case EM_M32R:
12371 return reloc_type == 34; /* R_M32R_32_RELA. */
12372 case EM_68HC11:
12373 case EM_68HC12:
12374 return reloc_type == 6; /* R_M68HC11_32. */
12375 case EM_S12Z:
12376 return reloc_type == 6; /* R_S12Z_EXT32. */
12377 case EM_MCORE:
12378 return reloc_type == 1; /* R_MCORE_ADDR32. */
12379 case EM_CYGNUS_MEP:
12380 return reloc_type == 4; /* R_MEP_32. */
12381 case EM_METAG:
12382 return reloc_type == 2; /* R_METAG_ADDR32. */
12383 case EM_MICROBLAZE:
12384 return reloc_type == 1; /* R_MICROBLAZE_32. */
12385 case EM_MIPS:
12386 return reloc_type == 2; /* R_MIPS_32. */
12387 case EM_MMIX:
12388 return reloc_type == 4; /* R_MMIX_32. */
12389 case EM_CYGNUS_MN10200:
12390 case EM_MN10200:
12391 return reloc_type == 1; /* R_MN10200_32. */
12392 case EM_CYGNUS_MN10300:
12393 case EM_MN10300:
12394 return reloc_type == 1; /* R_MN10300_32. */
12395 case EM_MOXIE:
12396 return reloc_type == 1; /* R_MOXIE_32. */
12397 case EM_MSP430_OLD:
12398 case EM_MSP430:
12399 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12400 case EM_MT:
12401 return reloc_type == 2; /* R_MT_32. */
12402 case EM_NDS32:
12403 return reloc_type == 20; /* R_NDS32_RELA. */
12404 case EM_ALTERA_NIOS2:
12405 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12406 case EM_NIOS32:
12407 return reloc_type == 1; /* R_NIOS_32. */
12408 case EM_OR1K:
12409 return reloc_type == 1; /* R_OR1K_32. */
12410 case EM_PARISC:
12411 return (reloc_type == 1 /* R_PARISC_DIR32. */
12412 || reloc_type == 2 /* R_PARISC_DIR21L. */
12413 || reloc_type == 41); /* R_PARISC_SECREL32. */
12414 case EM_PJ:
12415 case EM_PJ_OLD:
12416 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12417 case EM_PPC64:
12418 return reloc_type == 1; /* R_PPC64_ADDR32. */
12419 case EM_PPC:
12420 return reloc_type == 1; /* R_PPC_ADDR32. */
12421 case EM_TI_PRU:
12422 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12423 case EM_RISCV:
12424 return reloc_type == 1; /* R_RISCV_32. */
12425 case EM_RL78:
12426 return reloc_type == 1; /* R_RL78_DIR32. */
12427 case EM_RX:
12428 return reloc_type == 1; /* R_RX_DIR32. */
12429 case EM_S370:
12430 return reloc_type == 1; /* R_I370_ADDR31. */
12431 case EM_S390_OLD:
12432 case EM_S390:
12433 return reloc_type == 4; /* R_S390_32. */
12434 case EM_SCORE:
12435 return reloc_type == 8; /* R_SCORE_ABS32. */
12436 case EM_SH:
12437 return reloc_type == 1; /* R_SH_DIR32. */
12438 case EM_SPARC32PLUS:
12439 case EM_SPARCV9:
12440 case EM_SPARC:
12441 return reloc_type == 3 /* R_SPARC_32. */
12442 || reloc_type == 23; /* R_SPARC_UA32. */
12443 case EM_SPU:
12444 return reloc_type == 6; /* R_SPU_ADDR32 */
12445 case EM_TI_C6000:
12446 return reloc_type == 1; /* R_C6000_ABS32. */
12447 case EM_TILEGX:
12448 return reloc_type == 2; /* R_TILEGX_32. */
12449 case EM_TILEPRO:
12450 return reloc_type == 1; /* R_TILEPRO_32. */
12451 case EM_CYGNUS_V850:
12452 case EM_V850:
12453 return reloc_type == 6; /* R_V850_ABS32. */
12454 case EM_V800:
12455 return reloc_type == 0x33; /* R_V810_WORD. */
12456 case EM_VAX:
12457 return reloc_type == 1; /* R_VAX_32. */
12458 case EM_VISIUM:
12459 return reloc_type == 3; /* R_VISIUM_32. */
12460 case EM_WEBASSEMBLY:
12461 return reloc_type == 1; /* R_WASM32_32. */
12462 case EM_X86_64:
12463 case EM_L1OM:
12464 case EM_K1OM:
12465 return reloc_type == 10; /* R_X86_64_32. */
12466 case EM_XC16X:
12467 case EM_C166:
12468 return reloc_type == 3; /* R_XC16C_ABS_32. */
12469 case EM_XGATE:
12470 return reloc_type == 4; /* R_XGATE_32. */
12471 case EM_XSTORMY16:
12472 return reloc_type == 1; /* R_XSTROMY16_32. */
12473 case EM_XTENSA_OLD:
12474 case EM_XTENSA:
12475 return reloc_type == 1; /* R_XTENSA_32. */
12476 default:
12477 {
12478 static unsigned int prev_warn = 0;
12479
12480 /* Avoid repeating the same warning multiple times. */
12481 if (prev_warn != filedata->file_header.e_machine)
12482 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12483 filedata->file_header.e_machine);
12484 prev_warn = filedata->file_header.e_machine;
12485 return FALSE;
12486 }
12487 }
12488}
12489
12490/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12491 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12492
12493static bfd_boolean
12494is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12495{
12496 switch (filedata->file_header.e_machine)
12497 /* Please keep this table alpha-sorted for ease of visual lookup. */
12498 {
12499 case EM_386:
12500 case EM_IAMCU:
12501 return reloc_type == 2; /* R_386_PC32. */
12502 case EM_68K:
12503 return reloc_type == 4; /* R_68K_PC32. */
12504 case EM_AARCH64:
12505 return reloc_type == 261; /* R_AARCH64_PREL32 */
12506 case EM_ADAPTEVA_EPIPHANY:
12507 return reloc_type == 6;
12508 case EM_ALPHA:
12509 return reloc_type == 10; /* R_ALPHA_SREL32. */
12510 case EM_ARC_COMPACT:
12511 case EM_ARC_COMPACT2:
12512 return reloc_type == 49; /* R_ARC_32_PCREL. */
12513 case EM_ARM:
12514 return reloc_type == 3; /* R_ARM_REL32 */
12515 case EM_AVR_OLD:
12516 case EM_AVR:
12517 return reloc_type == 36; /* R_AVR_32_PCREL. */
12518 case EM_MICROBLAZE:
12519 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12520 case EM_OR1K:
12521 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12522 case EM_PARISC:
12523 return reloc_type == 9; /* R_PARISC_PCREL32. */
12524 case EM_PPC:
12525 return reloc_type == 26; /* R_PPC_REL32. */
12526 case EM_PPC64:
12527 return reloc_type == 26; /* R_PPC64_REL32. */
12528 case EM_S390_OLD:
12529 case EM_S390:
12530 return reloc_type == 5; /* R_390_PC32. */
12531 case EM_SH:
12532 return reloc_type == 2; /* R_SH_REL32. */
12533 case EM_SPARC32PLUS:
12534 case EM_SPARCV9:
12535 case EM_SPARC:
12536 return reloc_type == 6; /* R_SPARC_DISP32. */
12537 case EM_SPU:
12538 return reloc_type == 13; /* R_SPU_REL32. */
12539 case EM_TILEGX:
12540 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12541 case EM_TILEPRO:
12542 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12543 case EM_VISIUM:
12544 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12545 case EM_X86_64:
12546 case EM_L1OM:
12547 case EM_K1OM:
12548 return reloc_type == 2; /* R_X86_64_PC32. */
12549 case EM_XTENSA_OLD:
12550 case EM_XTENSA:
12551 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12552 default:
12553 /* Do not abort or issue an error message here. Not all targets use
12554 pc-relative 32-bit relocs in their DWARF debug information and we
12555 have already tested for target coverage in is_32bit_abs_reloc. A
12556 more helpful warning message will be generated by apply_relocations
12557 anyway, so just return. */
12558 return FALSE;
12559 }
12560}
12561
12562/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12563 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12564
12565static bfd_boolean
12566is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12567{
12568 switch (filedata->file_header.e_machine)
12569 {
12570 case EM_AARCH64:
12571 return reloc_type == 257; /* R_AARCH64_ABS64. */
12572 case EM_ALPHA:
12573 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12574 case EM_IA_64:
12575 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12576 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12577 case EM_PARISC:
12578 return reloc_type == 80; /* R_PARISC_DIR64. */
12579 case EM_PPC64:
12580 return reloc_type == 38; /* R_PPC64_ADDR64. */
12581 case EM_RISCV:
12582 return reloc_type == 2; /* R_RISCV_64. */
12583 case EM_SPARC32PLUS:
12584 case EM_SPARCV9:
12585 case EM_SPARC:
12586 return reloc_type == 32 /* R_SPARC_64. */
12587 || reloc_type == 54; /* R_SPARC_UA64. */
12588 case EM_X86_64:
12589 case EM_L1OM:
12590 case EM_K1OM:
12591 return reloc_type == 1; /* R_X86_64_64. */
12592 case EM_S390_OLD:
12593 case EM_S390:
12594 return reloc_type == 22; /* R_S390_64. */
12595 case EM_TILEGX:
12596 return reloc_type == 1; /* R_TILEGX_64. */
12597 case EM_MIPS:
12598 return reloc_type == 18; /* R_MIPS_64. */
12599 default:
12600 return FALSE;
12601 }
12602}
12603
12604/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12605 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12606
12607static bfd_boolean
12608is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12609{
12610 switch (filedata->file_header.e_machine)
12611 {
12612 case EM_AARCH64:
12613 return reloc_type == 260; /* R_AARCH64_PREL64. */
12614 case EM_ALPHA:
12615 return reloc_type == 11; /* R_ALPHA_SREL64. */
12616 case EM_IA_64:
12617 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12618 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12619 case EM_PARISC:
12620 return reloc_type == 72; /* R_PARISC_PCREL64. */
12621 case EM_PPC64:
12622 return reloc_type == 44; /* R_PPC64_REL64. */
12623 case EM_SPARC32PLUS:
12624 case EM_SPARCV9:
12625 case EM_SPARC:
12626 return reloc_type == 46; /* R_SPARC_DISP64. */
12627 case EM_X86_64:
12628 case EM_L1OM:
12629 case EM_K1OM:
12630 return reloc_type == 24; /* R_X86_64_PC64. */
12631 case EM_S390_OLD:
12632 case EM_S390:
12633 return reloc_type == 23; /* R_S390_PC64. */
12634 case EM_TILEGX:
12635 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12636 default:
12637 return FALSE;
12638 }
12639}
12640
12641/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12642 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12643
12644static bfd_boolean
12645is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12646{
12647 switch (filedata->file_header.e_machine)
12648 {
12649 case EM_CYGNUS_MN10200:
12650 case EM_MN10200:
12651 return reloc_type == 4; /* R_MN10200_24. */
12652 case EM_FT32:
12653 return reloc_type == 5; /* R_FT32_20. */
12654 default:
12655 return FALSE;
12656 }
12657}
12658
12659/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12660 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12661
12662static bfd_boolean
12663is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12664{
12665 /* Please keep this table alpha-sorted for ease of visual lookup. */
12666 switch (filedata->file_header.e_machine)
12667 {
12668 case EM_ARC:
12669 case EM_ARC_COMPACT:
12670 case EM_ARC_COMPACT2:
12671 return reloc_type == 2; /* R_ARC_16. */
12672 case EM_ADAPTEVA_EPIPHANY:
12673 return reloc_type == 5;
12674 case EM_AVR_OLD:
12675 case EM_AVR:
12676 return reloc_type == 4; /* R_AVR_16. */
12677 case EM_CYGNUS_D10V:
12678 case EM_D10V:
12679 return reloc_type == 3; /* R_D10V_16. */
12680 case EM_FT32:
12681 return reloc_type == 2; /* R_FT32_16. */
12682 case EM_H8S:
12683 case EM_H8_300:
12684 case EM_H8_300H:
12685 return reloc_type == R_H8_DIR16;
12686 case EM_IP2K_OLD:
12687 case EM_IP2K:
12688 return reloc_type == 1; /* R_IP2K_16. */
12689 case EM_M32C_OLD:
12690 case EM_M32C:
12691 return reloc_type == 1; /* R_M32C_16 */
12692 case EM_CYGNUS_MN10200:
12693 case EM_MN10200:
12694 return reloc_type == 2; /* R_MN10200_16. */
12695 case EM_CYGNUS_MN10300:
12696 case EM_MN10300:
12697 return reloc_type == 2; /* R_MN10300_16. */
12698 case EM_MSP430:
12699 if (uses_msp430x_relocs (filedata))
12700 return reloc_type == 2; /* R_MSP430_ABS16. */
12701 /* Fall through. */
12702 case EM_MSP430_OLD:
12703 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12704 case EM_NDS32:
12705 return reloc_type == 19; /* R_NDS32_RELA. */
12706 case EM_ALTERA_NIOS2:
12707 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12708 case EM_NIOS32:
12709 return reloc_type == 9; /* R_NIOS_16. */
12710 case EM_OR1K:
12711 return reloc_type == 2; /* R_OR1K_16. */
12712 case EM_RISCV:
12713 return reloc_type == 55; /* R_RISCV_SET16. */
12714 case EM_TI_PRU:
12715 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12716 case EM_TI_C6000:
12717 return reloc_type == 2; /* R_C6000_ABS16. */
12718 case EM_VISIUM:
12719 return reloc_type == 2; /* R_VISIUM_16. */
12720 case EM_XC16X:
12721 case EM_C166:
12722 return reloc_type == 2; /* R_XC16C_ABS_16. */
12723 case EM_XGATE:
12724 return reloc_type == 3; /* R_XGATE_16. */
12725 default:
12726 return FALSE;
12727 }
12728}
12729
12730/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12731 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12732
12733static bfd_boolean
12734is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12735{
12736 switch (filedata->file_header.e_machine)
12737 {
12738 case EM_RISCV:
12739 return reloc_type == 54; /* R_RISCV_SET8. */
12740 default:
12741 return FALSE;
12742 }
12743}
12744
12745/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12746 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12747
12748static bfd_boolean
12749is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12750{
12751 switch (filedata->file_header.e_machine)
12752 {
12753 case EM_RISCV:
12754 return reloc_type == 53; /* R_RISCV_SET6. */
12755 default:
12756 return FALSE;
12757 }
12758}
12759
12760/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12761 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12762
12763static bfd_boolean
12764is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12765{
12766 /* Please keep this table alpha-sorted for ease of visual lookup. */
12767 switch (filedata->file_header.e_machine)
12768 {
12769 case EM_RISCV:
12770 return reloc_type == 35; /* R_RISCV_ADD32. */
12771 default:
12772 return FALSE;
12773 }
12774}
12775
12776/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12778
12779static bfd_boolean
12780is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12781{
12782 /* Please keep this table alpha-sorted for ease of visual lookup. */
12783 switch (filedata->file_header.e_machine)
12784 {
12785 case EM_RISCV:
12786 return reloc_type == 39; /* R_RISCV_SUB32. */
12787 default:
12788 return FALSE;
12789 }
12790}
12791
12792/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12793 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12794
12795static bfd_boolean
12796is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12797{
12798 /* Please keep this table alpha-sorted for ease of visual lookup. */
12799 switch (filedata->file_header.e_machine)
12800 {
12801 case EM_RISCV:
12802 return reloc_type == 36; /* R_RISCV_ADD64. */
12803 default:
12804 return FALSE;
12805 }
12806}
12807
12808/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12809 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12810
12811static bfd_boolean
12812is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12813{
12814 /* Please keep this table alpha-sorted for ease of visual lookup. */
12815 switch (filedata->file_header.e_machine)
12816 {
12817 case EM_RISCV:
12818 return reloc_type == 40; /* R_RISCV_SUB64. */
12819 default:
12820 return FALSE;
12821 }
12822}
12823
12824/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12825 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12826
12827static bfd_boolean
12828is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12829{
12830 /* Please keep this table alpha-sorted for ease of visual lookup. */
12831 switch (filedata->file_header.e_machine)
12832 {
12833 case EM_RISCV:
12834 return reloc_type == 34; /* R_RISCV_ADD16. */
12835 default:
12836 return FALSE;
12837 }
12838}
12839
12840/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12841 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12842
12843static bfd_boolean
12844is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12845{
12846 /* Please keep this table alpha-sorted for ease of visual lookup. */
12847 switch (filedata->file_header.e_machine)
12848 {
12849 case EM_RISCV:
12850 return reloc_type == 38; /* R_RISCV_SUB16. */
12851 default:
12852 return FALSE;
12853 }
12854}
12855
12856/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12857 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12858
12859static bfd_boolean
12860is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12861{
12862 /* Please keep this table alpha-sorted for ease of visual lookup. */
12863 switch (filedata->file_header.e_machine)
12864 {
12865 case EM_RISCV:
12866 return reloc_type == 33; /* R_RISCV_ADD8. */
12867 default:
12868 return FALSE;
12869 }
12870}
12871
12872/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12873 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12874
12875static bfd_boolean
12876is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12877{
12878 /* Please keep this table alpha-sorted for ease of visual lookup. */
12879 switch (filedata->file_header.e_machine)
12880 {
12881 case EM_RISCV:
12882 return reloc_type == 37; /* R_RISCV_SUB8. */
12883 default:
12884 return FALSE;
12885 }
12886}
12887
12888/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12889 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12890
12891static bfd_boolean
12892is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12893{
12894 switch (filedata->file_header.e_machine)
12895 {
12896 case EM_RISCV:
12897 return reloc_type == 52; /* R_RISCV_SUB6. */
12898 default:
12899 return FALSE;
12900 }
12901}
12902
12903/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12904 relocation entries (possibly formerly used for SHT_GROUP sections). */
12905
12906static bfd_boolean
12907is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12908{
12909 switch (filedata->file_header.e_machine)
12910 {
12911 case EM_386: /* R_386_NONE. */
12912 case EM_68K: /* R_68K_NONE. */
12913 case EM_ADAPTEVA_EPIPHANY:
12914 case EM_ALPHA: /* R_ALPHA_NONE. */
12915 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12916 case EM_ARC: /* R_ARC_NONE. */
12917 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12918 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12919 case EM_ARM: /* R_ARM_NONE. */
12920 case EM_C166: /* R_XC16X_NONE. */
12921 case EM_CRIS: /* R_CRIS_NONE. */
12922 case EM_FT32: /* R_FT32_NONE. */
12923 case EM_IA_64: /* R_IA64_NONE. */
12924 case EM_K1OM: /* R_X86_64_NONE. */
12925 case EM_L1OM: /* R_X86_64_NONE. */
12926 case EM_M32R: /* R_M32R_NONE. */
12927 case EM_MIPS: /* R_MIPS_NONE. */
12928 case EM_MN10300: /* R_MN10300_NONE. */
12929 case EM_MOXIE: /* R_MOXIE_NONE. */
12930 case EM_NIOS32: /* R_NIOS_NONE. */
12931 case EM_OR1K: /* R_OR1K_NONE. */
12932 case EM_PARISC: /* R_PARISC_NONE. */
12933 case EM_PPC64: /* R_PPC64_NONE. */
12934 case EM_PPC: /* R_PPC_NONE. */
12935 case EM_RISCV: /* R_RISCV_NONE. */
12936 case EM_S390: /* R_390_NONE. */
12937 case EM_S390_OLD:
12938 case EM_SH: /* R_SH_NONE. */
12939 case EM_SPARC32PLUS:
12940 case EM_SPARC: /* R_SPARC_NONE. */
12941 case EM_SPARCV9:
12942 case EM_TILEGX: /* R_TILEGX_NONE. */
12943 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12944 case EM_TI_C6000:/* R_C6000_NONE. */
12945 case EM_X86_64: /* R_X86_64_NONE. */
12946 case EM_XC16X:
12947 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12948 return reloc_type == 0;
12949
12950 case EM_AARCH64:
12951 return reloc_type == 0 || reloc_type == 256;
12952 case EM_AVR_OLD:
12953 case EM_AVR:
12954 return (reloc_type == 0 /* R_AVR_NONE. */
12955 || reloc_type == 30 /* R_AVR_DIFF8. */
12956 || reloc_type == 31 /* R_AVR_DIFF16. */
12957 || reloc_type == 32 /* R_AVR_DIFF32. */);
12958 case EM_METAG:
12959 return reloc_type == 3; /* R_METAG_NONE. */
12960 case EM_NDS32:
12961 return (reloc_type == 0 /* R_XTENSA_NONE. */
12962 || reloc_type == 204 /* R_NDS32_DIFF8. */
12963 || reloc_type == 205 /* R_NDS32_DIFF16. */
12964 || reloc_type == 206 /* R_NDS32_DIFF32. */
12965 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12966 case EM_TI_PRU:
12967 return (reloc_type == 0 /* R_PRU_NONE. */
12968 || reloc_type == 65 /* R_PRU_DIFF8. */
12969 || reloc_type == 66 /* R_PRU_DIFF16. */
12970 || reloc_type == 67 /* R_PRU_DIFF32. */);
12971 case EM_XTENSA_OLD:
12972 case EM_XTENSA:
12973 return (reloc_type == 0 /* R_XTENSA_NONE. */
12974 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12975 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12976 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12977 }
12978 return FALSE;
12979}
12980
12981/* Returns TRUE if there is a relocation against
12982 section NAME at OFFSET bytes. */
12983
12984bfd_boolean
12985reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12986{
12987 Elf_Internal_Rela * relocs;
12988 Elf_Internal_Rela * rp;
12989
12990 if (dsec == NULL || dsec->reloc_info == NULL)
12991 return FALSE;
12992
12993 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12994
12995 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12996 if (rp->r_offset == offset)
12997 return TRUE;
12998
12999 return FALSE;
13000}
13001
13002/* Apply relocations to a section.
13003 Returns TRUE upon success, FALSE otherwise.
13004 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13005 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13006 will be set to the number of relocs loaded.
13007
13008 Note: So far support has been added only for those relocations
13009 which can be found in debug sections. FIXME: Add support for
13010 more relocations ? */
13011
13012static bfd_boolean
13013apply_relocations (Filedata * filedata,
13014 const Elf_Internal_Shdr * section,
13015 unsigned char * start,
13016 bfd_size_type size,
13017 void ** relocs_return,
13018 unsigned long * num_relocs_return)
13019{
13020 Elf_Internal_Shdr * relsec;
13021 unsigned char * end = start + size;
13022 bfd_boolean res = TRUE;
13023
13024 if (relocs_return != NULL)
13025 {
13026 * (Elf_Internal_Rela **) relocs_return = NULL;
13027 * num_relocs_return = 0;
13028 }
13029
13030 if (filedata->file_header.e_type != ET_REL)
13031 /* No relocs to apply. */
13032 return TRUE;
13033
13034 /* Find the reloc section associated with the section. */
13035 for (relsec = filedata->section_headers;
13036 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13037 ++relsec)
13038 {
13039 bfd_boolean is_rela;
13040 unsigned long num_relocs;
13041 Elf_Internal_Rela * relocs;
13042 Elf_Internal_Rela * rp;
13043 Elf_Internal_Shdr * symsec;
13044 Elf_Internal_Sym * symtab;
13045 unsigned long num_syms;
13046 Elf_Internal_Sym * sym;
13047
13048 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13049 || relsec->sh_info >= filedata->file_header.e_shnum
13050 || filedata->section_headers + relsec->sh_info != section
13051 || relsec->sh_size == 0
13052 || relsec->sh_link >= filedata->file_header.e_shnum)
13053 continue;
13054
13055 is_rela = relsec->sh_type == SHT_RELA;
13056
13057 if (is_rela)
13058 {
13059 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13060 relsec->sh_size, & relocs, & num_relocs))
13061 return FALSE;
13062 }
13063 else
13064 {
13065 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13066 relsec->sh_size, & relocs, & num_relocs))
13067 return FALSE;
13068 }
13069
13070 /* SH uses RELA but uses in place value instead of the addend field. */
13071 if (filedata->file_header.e_machine == EM_SH)
13072 is_rela = FALSE;
13073
13074 symsec = filedata->section_headers + relsec->sh_link;
13075 if (symsec->sh_type != SHT_SYMTAB
13076 && symsec->sh_type != SHT_DYNSYM)
13077 return FALSE;
13078 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13079
13080 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13081 {
13082 bfd_vma addend;
13083 unsigned int reloc_type;
13084 unsigned int reloc_size;
13085 bfd_boolean reloc_inplace = FALSE;
13086 bfd_boolean reloc_subtract = FALSE;
13087 unsigned char * rloc;
13088 unsigned long sym_index;
13089
13090 reloc_type = get_reloc_type (filedata, rp->r_info);
13091
13092 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13093 continue;
13094 else if (is_none_reloc (filedata, reloc_type))
13095 continue;
13096 else if (is_32bit_abs_reloc (filedata, reloc_type)
13097 || is_32bit_pcrel_reloc (filedata, reloc_type))
13098 reloc_size = 4;
13099 else if (is_64bit_abs_reloc (filedata, reloc_type)
13100 || is_64bit_pcrel_reloc (filedata, reloc_type))
13101 reloc_size = 8;
13102 else if (is_24bit_abs_reloc (filedata, reloc_type))
13103 reloc_size = 3;
13104 else if (is_16bit_abs_reloc (filedata, reloc_type))
13105 reloc_size = 2;
13106 else if (is_8bit_abs_reloc (filedata, reloc_type)
13107 || is_6bit_abs_reloc (filedata, reloc_type))
13108 reloc_size = 1;
13109 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13110 reloc_type))
13111 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13112 {
13113 reloc_size = 4;
13114 reloc_inplace = TRUE;
13115 }
13116 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13117 reloc_type))
13118 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13119 {
13120 reloc_size = 8;
13121 reloc_inplace = TRUE;
13122 }
13123 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13124 reloc_type))
13125 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13126 {
13127 reloc_size = 2;
13128 reloc_inplace = TRUE;
13129 }
13130 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13131 reloc_type))
13132 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13133 {
13134 reloc_size = 1;
13135 reloc_inplace = TRUE;
13136 }
13137 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13138 reloc_type)))
13139 {
13140 reloc_size = 1;
13141 reloc_inplace = TRUE;
13142 }
13143 else
13144 {
13145 static unsigned int prev_reloc = 0;
13146
13147 if (reloc_type != prev_reloc)
13148 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13149 reloc_type, printable_section_name (filedata, section));
13150 prev_reloc = reloc_type;
13151 res = FALSE;
13152 continue;
13153 }
13154
13155 rloc = start + rp->r_offset;
13156 if ((rloc + reloc_size) > end || (rloc < start))
13157 {
13158 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13159 (unsigned long) rp->r_offset,
13160 printable_section_name (filedata, section));
13161 res = FALSE;
13162 continue;
13163 }
13164
13165 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13166 if (sym_index >= num_syms)
13167 {
13168 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13169 sym_index, printable_section_name (filedata, section));
13170 res = FALSE;
13171 continue;
13172 }
13173 sym = symtab + sym_index;
13174
13175 /* If the reloc has a symbol associated with it,
13176 make sure that it is of an appropriate type.
13177
13178 Relocations against symbols without type can happen.
13179 Gcc -feliminate-dwarf2-dups may generate symbols
13180 without type for debug info.
13181
13182 Icc generates relocations against function symbols
13183 instead of local labels.
13184
13185 Relocations against object symbols can happen, eg when
13186 referencing a global array. For an example of this see
13187 the _clz.o binary in libgcc.a. */
13188 if (sym != symtab
13189 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13190 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13191 {
13192 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13193 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13194 printable_section_name (filedata, relsec),
13195 (long int)(rp - relocs));
13196 res = FALSE;
13197 continue;
13198 }
13199
13200 addend = 0;
13201 if (is_rela)
13202 addend += rp->r_addend;
13203 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13204 partial_inplace. */
13205 if (!is_rela
13206 || (filedata->file_header.e_machine == EM_XTENSA
13207 && reloc_type == 1)
13208 || ((filedata->file_header.e_machine == EM_PJ
13209 || filedata->file_header.e_machine == EM_PJ_OLD)
13210 && reloc_type == 1)
13211 || ((filedata->file_header.e_machine == EM_D30V
13212 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13213 && reloc_type == 12)
13214 || reloc_inplace)
13215 {
13216 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13217 addend += byte_get (rloc, reloc_size) & 0x3f;
13218 else
13219 addend += byte_get (rloc, reloc_size);
13220 }
13221
13222 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13223 || is_64bit_pcrel_reloc (filedata, reloc_type))
13224 {
13225 /* On HPPA, all pc-relative relocations are biased by 8. */
13226 if (filedata->file_header.e_machine == EM_PARISC)
13227 addend -= 8;
13228 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13229 reloc_size);
13230 }
13231 else if (is_6bit_abs_reloc (filedata, reloc_type)
13232 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13233 {
13234 if (reloc_subtract)
13235 addend -= sym->st_value;
13236 else
13237 addend += sym->st_value;
13238 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13239 byte_put (rloc, addend, reloc_size);
13240 }
13241 else if (reloc_subtract)
13242 byte_put (rloc, addend - sym->st_value, reloc_size);
13243 else
13244 byte_put (rloc, addend + sym->st_value, reloc_size);
13245 }
13246
13247 free (symtab);
13248 /* Let the target specific reloc processing code know that
13249 we have finished with these relocs. */
13250 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13251
13252 if (relocs_return)
13253 {
13254 * (Elf_Internal_Rela **) relocs_return = relocs;
13255 * num_relocs_return = num_relocs;
13256 }
13257 else
13258 free (relocs);
13259
13260 break;
13261 }
13262
13263 return res;
13264}
13265
13266#ifdef SUPPORT_DISASSEMBLY
13267static bfd_boolean
13268disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13269{
13270 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13271
13272 /* FIXME: XXX -- to be done --- XXX */
13273
13274 return TRUE;
13275}
13276#endif
13277
13278/* Reads in the contents of SECTION from FILE, returning a pointer
13279 to a malloc'ed buffer or NULL if something went wrong. */
13280
13281static char *
13282get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13283{
13284 bfd_size_type num_bytes = section->sh_size;
13285
13286 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13287 {
13288 printf (_("Section '%s' has no data to dump.\n"),
13289 printable_section_name (filedata, section));
13290 return NULL;
13291 }
13292
13293 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13294 _("section contents"));
13295}
13296
13297/* Uncompresses a section that was compressed using zlib, in place. */
13298
13299static bfd_boolean
13300uncompress_section_contents (unsigned char ** buffer,
13301 dwarf_size_type uncompressed_size,
13302 dwarf_size_type * size)
13303{
13304 dwarf_size_type compressed_size = *size;
13305 unsigned char * compressed_buffer = *buffer;
13306 unsigned char * uncompressed_buffer;
13307 z_stream strm;
13308 int rc;
13309
13310 /* It is possible the section consists of several compressed
13311 buffers concatenated together, so we uncompress in a loop. */
13312 /* PR 18313: The state field in the z_stream structure is supposed
13313 to be invisible to the user (ie us), but some compilers will
13314 still complain about it being used without initialisation. So
13315 we first zero the entire z_stream structure and then set the fields
13316 that we need. */
13317 memset (& strm, 0, sizeof strm);
13318 strm.avail_in = compressed_size;
13319 strm.next_in = (Bytef *) compressed_buffer;
13320 strm.avail_out = uncompressed_size;
13321 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13322
13323 rc = inflateInit (& strm);
13324 while (strm.avail_in > 0)
13325 {
13326 if (rc != Z_OK)
13327 goto fail;
13328 strm.next_out = ((Bytef *) uncompressed_buffer
13329 + (uncompressed_size - strm.avail_out));
13330 rc = inflate (&strm, Z_FINISH);
13331 if (rc != Z_STREAM_END)
13332 goto fail;
13333 rc = inflateReset (& strm);
13334 }
13335 rc = inflateEnd (& strm);
13336 if (rc != Z_OK
13337 || strm.avail_out != 0)
13338 goto fail;
13339
13340 *buffer = uncompressed_buffer;
13341 *size = uncompressed_size;
13342 return TRUE;
13343
13344 fail:
13345 free (uncompressed_buffer);
13346 /* Indicate decompression failure. */
13347 *buffer = NULL;
13348 return FALSE;
13349}
13350
13351static bfd_boolean
13352dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13353{
13354 Elf_Internal_Shdr * relsec;
13355 bfd_size_type num_bytes;
13356 unsigned char * data;
13357 unsigned char * end;
13358 unsigned char * real_start;
13359 unsigned char * start;
13360 bfd_boolean some_strings_shown;
13361
13362 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13363 if (start == NULL)
13364 /* PR 21820: Do not fail if the section was empty. */
13365 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13366
13367 num_bytes = section->sh_size;
13368
13369 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13370
13371 if (decompress_dumps)
13372 {
13373 dwarf_size_type new_size = num_bytes;
13374 dwarf_size_type uncompressed_size = 0;
13375
13376 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13377 {
13378 Elf_Internal_Chdr chdr;
13379 unsigned int compression_header_size
13380 = get_compression_header (& chdr, (unsigned char *) start,
13381 num_bytes);
13382
13383 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13384 {
13385 warn (_("section '%s' has unsupported compress type: %d\n"),
13386 printable_section_name (filedata, section), chdr.ch_type);
13387 return FALSE;
13388 }
13389 else if (chdr.ch_addralign != section->sh_addralign)
13390 {
13391 warn (_("compressed section '%s' is corrupted\n"),
13392 printable_section_name (filedata, section));
13393 return FALSE;
13394 }
13395 uncompressed_size = chdr.ch_size;
13396 start += compression_header_size;
13397 new_size -= compression_header_size;
13398 }
13399 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13400 {
13401 /* Read the zlib header. In this case, it should be "ZLIB"
13402 followed by the uncompressed section size, 8 bytes in
13403 big-endian order. */
13404 uncompressed_size = start[4]; uncompressed_size <<= 8;
13405 uncompressed_size += start[5]; uncompressed_size <<= 8;
13406 uncompressed_size += start[6]; uncompressed_size <<= 8;
13407 uncompressed_size += start[7]; uncompressed_size <<= 8;
13408 uncompressed_size += start[8]; uncompressed_size <<= 8;
13409 uncompressed_size += start[9]; uncompressed_size <<= 8;
13410 uncompressed_size += start[10]; uncompressed_size <<= 8;
13411 uncompressed_size += start[11];
13412 start += 12;
13413 new_size -= 12;
13414 }
13415
13416 if (uncompressed_size)
13417 {
13418 if (uncompress_section_contents (& start,
13419 uncompressed_size, & new_size))
13420 num_bytes = new_size;
13421 else
13422 {
13423 error (_("Unable to decompress section %s\n"),
13424 printable_section_name (filedata, section));
13425 return FALSE;
13426 }
13427 }
13428 else
13429 start = real_start;
13430 }
13431
13432 /* If the section being dumped has relocations against it the user might
13433 be expecting these relocations to have been applied. Check for this
13434 case and issue a warning message in order to avoid confusion.
13435 FIXME: Maybe we ought to have an option that dumps a section with
13436 relocs applied ? */
13437 for (relsec = filedata->section_headers;
13438 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13439 ++relsec)
13440 {
13441 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13442 || relsec->sh_info >= filedata->file_header.e_shnum
13443 || filedata->section_headers + relsec->sh_info != section
13444 || relsec->sh_size == 0
13445 || relsec->sh_link >= filedata->file_header.e_shnum)
13446 continue;
13447
13448 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13449 break;
13450 }
13451
13452 data = start;
13453 end = start + num_bytes;
13454 some_strings_shown = FALSE;
13455
13456 while (data < end)
13457 {
13458 while (!ISPRINT (* data))
13459 if (++ data >= end)
13460 break;
13461
13462 if (data < end)
13463 {
13464 size_t maxlen = end - data;
13465
13466#ifndef __MSVCRT__
13467 /* PR 11128: Use two separate invocations in order to work
13468 around bugs in the Solaris 8 implementation of printf. */
13469 printf (" [%6tx] ", data - start);
13470#else
13471 printf (" [%6Ix] ", (size_t) (data - start));
13472#endif
13473 if (maxlen > 0)
13474 {
13475 print_symbol ((int) maxlen, (const char *) data);
13476 putchar ('\n');
13477 data += strnlen ((const char *) data, maxlen);
13478 }
13479 else
13480 {
13481 printf (_("<corrupt>\n"));
13482 data = end;
13483 }
13484 some_strings_shown = TRUE;
13485 }
13486 }
13487
13488 if (! some_strings_shown)
13489 printf (_(" No strings found in this section."));
13490
13491 free (real_start);
13492
13493 putchar ('\n');
13494 return TRUE;
13495}
13496
13497static bfd_boolean
13498dump_section_as_bytes (Elf_Internal_Shdr * section,
13499 Filedata * filedata,
13500 bfd_boolean relocate)
13501{
13502 Elf_Internal_Shdr * relsec;
13503 bfd_size_type bytes;
13504 bfd_size_type section_size;
13505 bfd_vma addr;
13506 unsigned char * data;
13507 unsigned char * real_start;
13508 unsigned char * start;
13509
13510 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13511 if (start == NULL)
13512 /* PR 21820: Do not fail if the section was empty. */
13513 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13514
13515 section_size = section->sh_size;
13516
13517 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13518
13519 if (decompress_dumps)
13520 {
13521 dwarf_size_type new_size = section_size;
13522 dwarf_size_type uncompressed_size = 0;
13523
13524 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13525 {
13526 Elf_Internal_Chdr chdr;
13527 unsigned int compression_header_size
13528 = get_compression_header (& chdr, start, section_size);
13529
13530 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13531 {
13532 warn (_("section '%s' has unsupported compress type: %d\n"),
13533 printable_section_name (filedata, section), chdr.ch_type);
13534 return FALSE;
13535 }
13536 else if (chdr.ch_addralign != section->sh_addralign)
13537 {
13538 warn (_("compressed section '%s' is corrupted\n"),
13539 printable_section_name (filedata, section));
13540 return FALSE;
13541 }
13542 uncompressed_size = chdr.ch_size;
13543 start += compression_header_size;
13544 new_size -= compression_header_size;
13545 }
13546 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13547 {
13548 /* Read the zlib header. In this case, it should be "ZLIB"
13549 followed by the uncompressed section size, 8 bytes in
13550 big-endian order. */
13551 uncompressed_size = start[4]; uncompressed_size <<= 8;
13552 uncompressed_size += start[5]; uncompressed_size <<= 8;
13553 uncompressed_size += start[6]; uncompressed_size <<= 8;
13554 uncompressed_size += start[7]; uncompressed_size <<= 8;
13555 uncompressed_size += start[8]; uncompressed_size <<= 8;
13556 uncompressed_size += start[9]; uncompressed_size <<= 8;
13557 uncompressed_size += start[10]; uncompressed_size <<= 8;
13558 uncompressed_size += start[11];
13559 start += 12;
13560 new_size -= 12;
13561 }
13562
13563 if (uncompressed_size)
13564 {
13565 if (uncompress_section_contents (& start, uncompressed_size,
13566 & new_size))
13567 {
13568 section_size = new_size;
13569 }
13570 else
13571 {
13572 error (_("Unable to decompress section %s\n"),
13573 printable_section_name (filedata, section));
13574 /* FIXME: Print the section anyway ? */
13575 return FALSE;
13576 }
13577 }
13578 else
13579 start = real_start;
13580 }
13581
13582 if (relocate)
13583 {
13584 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13585 return FALSE;
13586 }
13587 else
13588 {
13589 /* If the section being dumped has relocations against it the user might
13590 be expecting these relocations to have been applied. Check for this
13591 case and issue a warning message in order to avoid confusion.
13592 FIXME: Maybe we ought to have an option that dumps a section with
13593 relocs applied ? */
13594 for (relsec = filedata->section_headers;
13595 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13596 ++relsec)
13597 {
13598 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13599 || relsec->sh_info >= filedata->file_header.e_shnum
13600 || filedata->section_headers + relsec->sh_info != section
13601 || relsec->sh_size == 0
13602 || relsec->sh_link >= filedata->file_header.e_shnum)
13603 continue;
13604
13605 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13606 break;
13607 }
13608 }
13609
13610 addr = section->sh_addr;
13611 bytes = section_size;
13612 data = start;
13613
13614 while (bytes)
13615 {
13616 int j;
13617 int k;
13618 int lbytes;
13619
13620 lbytes = (bytes > 16 ? 16 : bytes);
13621
13622 printf (" 0x%8.8lx ", (unsigned long) addr);
13623
13624 for (j = 0; j < 16; j++)
13625 {
13626 if (j < lbytes)
13627 printf ("%2.2x", data[j]);
13628 else
13629 printf (" ");
13630
13631 if ((j & 3) == 3)
13632 printf (" ");
13633 }
13634
13635 for (j = 0; j < lbytes; j++)
13636 {
13637 k = data[j];
13638 if (k >= ' ' && k < 0x7f)
13639 printf ("%c", k);
13640 else
13641 printf (".");
13642 }
13643
13644 putchar ('\n');
13645
13646 data += lbytes;
13647 addr += lbytes;
13648 bytes -= lbytes;
13649 }
13650
13651 free (real_start);
13652
13653 putchar ('\n');
13654 return TRUE;
13655}
13656
13657static bfd_boolean
13658load_specific_debug_section (enum dwarf_section_display_enum debug,
13659 const Elf_Internal_Shdr * sec,
13660 void * data)
13661{
13662 struct dwarf_section * section = &debug_displays [debug].section;
13663 char buf [64];
13664 Filedata * filedata = (Filedata *) data;
13665
13666 if (section->start != NULL)
13667 {
13668 /* If it is already loaded, do nothing. */
13669 if (streq (section->filename, filedata->file_name))
13670 return TRUE;
13671 free (section->start);
13672 }
13673
13674 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13675 section->address = sec->sh_addr;
13676 section->user_data = NULL;
13677 section->filename = filedata->file_name;
13678 section->start = (unsigned char *) get_data (NULL, filedata,
13679 sec->sh_offset, 1,
13680 sec->sh_size, buf);
13681 if (section->start == NULL)
13682 section->size = 0;
13683 else
13684 {
13685 unsigned char *start = section->start;
13686 dwarf_size_type size = sec->sh_size;
13687 dwarf_size_type uncompressed_size = 0;
13688
13689 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13690 {
13691 Elf_Internal_Chdr chdr;
13692 unsigned int compression_header_size;
13693
13694 if (size < (is_32bit_elf
13695 ? sizeof (Elf32_External_Chdr)
13696 : sizeof (Elf64_External_Chdr)))
13697 {
13698 warn (_("compressed section %s is too small to contain a compression header"),
13699 section->name);
13700 return FALSE;
13701 }
13702
13703 compression_header_size = get_compression_header (&chdr, start, size);
13704
13705 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13706 {
13707 warn (_("section '%s' has unsupported compress type: %d\n"),
13708 section->name, chdr.ch_type);
13709 return FALSE;
13710 }
13711 else if (chdr.ch_addralign != sec->sh_addralign)
13712 {
13713 warn (_("compressed section '%s' is corrupted\n"),
13714 section->name);
13715 return FALSE;
13716 }
13717 uncompressed_size = chdr.ch_size;
13718 start += compression_header_size;
13719 size -= compression_header_size;
13720 }
13721 else if (size > 12 && streq ((char *) start, "ZLIB"))
13722 {
13723 /* Read the zlib header. In this case, it should be "ZLIB"
13724 followed by the uncompressed section size, 8 bytes in
13725 big-endian order. */
13726 uncompressed_size = start[4]; uncompressed_size <<= 8;
13727 uncompressed_size += start[5]; uncompressed_size <<= 8;
13728 uncompressed_size += start[6]; uncompressed_size <<= 8;
13729 uncompressed_size += start[7]; uncompressed_size <<= 8;
13730 uncompressed_size += start[8]; uncompressed_size <<= 8;
13731 uncompressed_size += start[9]; uncompressed_size <<= 8;
13732 uncompressed_size += start[10]; uncompressed_size <<= 8;
13733 uncompressed_size += start[11];
13734 start += 12;
13735 size -= 12;
13736 }
13737
13738 if (uncompressed_size)
13739 {
13740 if (uncompress_section_contents (&start, uncompressed_size,
13741 &size))
13742 {
13743 /* Free the compressed buffer, update the section buffer
13744 and the section size if uncompress is successful. */
13745 free (section->start);
13746 section->start = start;
13747 }
13748 else
13749 {
13750 error (_("Unable to decompress section %s\n"),
13751 printable_section_name (filedata, sec));
13752 return FALSE;
13753 }
13754 }
13755
13756 section->size = size;
13757 }
13758
13759 if (section->start == NULL)
13760 return FALSE;
13761
13762 if (debug_displays [debug].relocate)
13763 {
13764 if (! apply_relocations (filedata, sec, section->start, section->size,
13765 & section->reloc_info, & section->num_relocs))
13766 return FALSE;
13767 }
13768 else
13769 {
13770 section->reloc_info = NULL;
13771 section->num_relocs = 0;
13772 }
13773
13774 return TRUE;
13775}
13776
13777/* If this is not NULL, load_debug_section will only look for sections
13778 within the list of sections given here. */
13779static unsigned int * section_subset = NULL;
13780
13781bfd_boolean
13782load_debug_section (enum dwarf_section_display_enum debug, void * data)
13783{
13784 struct dwarf_section * section = &debug_displays [debug].section;
13785 Elf_Internal_Shdr * sec;
13786 Filedata * filedata = (Filedata *) data;
13787
13788 /* Without section headers we cannot find any sections. */
13789 if (filedata->section_headers == NULL)
13790 return FALSE;
13791
13792 if (filedata->string_table == NULL
13793 && filedata->file_header.e_shstrndx != SHN_UNDEF
13794 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13795 {
13796 Elf_Internal_Shdr * strs;
13797
13798 /* Read in the string table, so that we have section names to scan. */
13799 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13800
13801 if (strs != NULL && strs->sh_size != 0)
13802 {
13803 filedata->string_table
13804 = (char *) get_data (NULL, filedata, strs->sh_offset,
13805 1, strs->sh_size, _("string table"));
13806
13807 filedata->string_table_length
13808 = filedata->string_table != NULL ? strs->sh_size : 0;
13809 }
13810 }
13811
13812 /* Locate the debug section. */
13813 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13814 if (sec != NULL)
13815 section->name = section->uncompressed_name;
13816 else
13817 {
13818 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13819 if (sec != NULL)
13820 section->name = section->compressed_name;
13821 }
13822 if (sec == NULL)
13823 return FALSE;
13824
13825 /* If we're loading from a subset of sections, and we've loaded
13826 a section matching this name before, it's likely that it's a
13827 different one. */
13828 if (section_subset != NULL)
13829 free_debug_section (debug);
13830
13831 return load_specific_debug_section (debug, sec, data);
13832}
13833
13834void
13835free_debug_section (enum dwarf_section_display_enum debug)
13836{
13837 struct dwarf_section * section = &debug_displays [debug].section;
13838
13839 if (section->start == NULL)
13840 return;
13841
13842 free ((char *) section->start);
13843 section->start = NULL;
13844 section->address = 0;
13845 section->size = 0;
13846}
13847
13848static bfd_boolean
13849display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13850{
13851 char * name = SECTION_NAME (section);
13852 const char * print_name = printable_section_name (filedata, section);
13853 bfd_size_type length;
13854 bfd_boolean result = TRUE;
13855 int i;
13856
13857 length = section->sh_size;
13858 if (length == 0)
13859 {
13860 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13861 return TRUE;
13862 }
13863 if (section->sh_type == SHT_NOBITS)
13864 {
13865 /* There is no point in dumping the contents of a debugging section
13866 which has the NOBITS type - the bits in the file will be random.
13867 This can happen when a file containing a .eh_frame section is
13868 stripped with the --only-keep-debug command line option. */
13869 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13870 print_name);
13871 return FALSE;
13872 }
13873
13874 if (const_strneq (name, ".gnu.linkonce.wi."))
13875 name = ".debug_info";
13876
13877 /* See if we know how to display the contents of this section. */
13878 for (i = 0; i < max; i++)
13879 {
13880 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
13881 struct dwarf_section_display * display = debug_displays + i;
13882 struct dwarf_section * sec = & display->section;
13883
13884 if (streq (sec->uncompressed_name, name)
13885 || (id == line && const_strneq (name, ".debug_line."))
13886 || streq (sec->compressed_name, name))
13887 {
13888 bfd_boolean secondary = (section != find_section (filedata, name));
13889
13890 if (secondary)
13891 free_debug_section (id);
13892
13893 if (i == line && const_strneq (name, ".debug_line."))
13894 sec->name = name;
13895 else if (streq (sec->uncompressed_name, name))
13896 sec->name = sec->uncompressed_name;
13897 else
13898 sec->name = sec->compressed_name;
13899
13900 if (load_specific_debug_section (id, section, filedata))
13901 {
13902 /* If this debug section is part of a CU/TU set in a .dwp file,
13903 restrict load_debug_section to the sections in that set. */
13904 section_subset = find_cu_tu_set (filedata, shndx);
13905
13906 result &= display->display (sec, filedata);
13907
13908 section_subset = NULL;
13909
13910 if (secondary || (id != info && id != abbrev))
13911 free_debug_section (id);
13912 }
13913 break;
13914 }
13915 }
13916
13917 if (i == max)
13918 {
13919 printf (_("Unrecognized debug section: %s\n"), print_name);
13920 result = FALSE;
13921 }
13922
13923 return result;
13924}
13925
13926/* Set DUMP_SECTS for all sections where dumps were requested
13927 based on section name. */
13928
13929static void
13930initialise_dumps_byname (Filedata * filedata)
13931{
13932 struct dump_list_entry * cur;
13933
13934 for (cur = dump_sects_byname; cur; cur = cur->next)
13935 {
13936 unsigned int i;
13937 bfd_boolean any = FALSE;
13938
13939 for (i = 0; i < filedata->file_header.e_shnum; i++)
13940 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13941 {
13942 request_dump_bynumber (filedata, i, cur->type);
13943 any = TRUE;
13944 }
13945
13946 if (!any)
13947 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13948 cur->name);
13949 }
13950}
13951
13952static bfd_boolean
13953process_section_contents (Filedata * filedata)
13954{
13955 Elf_Internal_Shdr * section;
13956 unsigned int i;
13957 bfd_boolean res = TRUE;
13958
13959 if (! do_dump)
13960 return TRUE;
13961
13962 initialise_dumps_byname (filedata);
13963
13964 for (i = 0, section = filedata->section_headers;
13965 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13966 i++, section++)
13967 {
13968 dump_type dump = filedata->dump_sects[i];
13969
13970#ifdef SUPPORT_DISASSEMBLY
13971 if (dump & DISASS_DUMP)
13972 {
13973 if (! disassemble_section (section, filedata))
13974 res = FALSE;
13975 }
13976#endif
13977 if (dump & HEX_DUMP)
13978 {
13979 if (! dump_section_as_bytes (section, filedata, FALSE))
13980 res = FALSE;
13981 }
13982
13983 if (dump & RELOC_DUMP)
13984 {
13985 if (! dump_section_as_bytes (section, filedata, TRUE))
13986 res = FALSE;
13987 }
13988
13989 if (dump & STRING_DUMP)
13990 {
13991 if (! dump_section_as_strings (section, filedata))
13992 res = FALSE;
13993 }
13994
13995 if (dump & DEBUG_DUMP)
13996 {
13997 if (! display_debug_section (i, section, filedata))
13998 res = FALSE;
13999 }
14000 }
14001
14002 /* Check to see if the user requested a
14003 dump of a section that does not exist. */
14004 while (i < filedata->num_dump_sects)
14005 {
14006 if (filedata->dump_sects[i])
14007 {
14008 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14009 res = FALSE;
14010 }
14011 i++;
14012 }
14013
14014 return res;
14015}
14016
14017static void
14018process_mips_fpe_exception (int mask)
14019{
14020 if (mask)
14021 {
14022 bfd_boolean first = TRUE;
14023
14024 if (mask & OEX_FPU_INEX)
14025 fputs ("INEX", stdout), first = FALSE;
14026 if (mask & OEX_FPU_UFLO)
14027 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14028 if (mask & OEX_FPU_OFLO)
14029 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14030 if (mask & OEX_FPU_DIV0)
14031 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14032 if (mask & OEX_FPU_INVAL)
14033 printf ("%sINVAL", first ? "" : "|");
14034 }
14035 else
14036 fputs ("0", stdout);
14037}
14038
14039/* Display's the value of TAG at location P. If TAG is
14040 greater than 0 it is assumed to be an unknown tag, and
14041 a message is printed to this effect. Otherwise it is
14042 assumed that a message has already been printed.
14043
14044 If the bottom bit of TAG is set it assumed to have a
14045 string value, otherwise it is assumed to have an integer
14046 value.
14047
14048 Returns an updated P pointing to the first unread byte
14049 beyond the end of TAG's value.
14050
14051 Reads at or beyond END will not be made. */
14052
14053static unsigned char *
14054display_tag_value (signed int tag,
14055 unsigned char * p,
14056 const unsigned char * const end)
14057{
14058 unsigned long val;
14059
14060 if (tag > 0)
14061 printf (" Tag_unknown_%d: ", tag);
14062
14063 if (p >= end)
14064 {
14065 warn (_("<corrupt tag>\n"));
14066 }
14067 else if (tag & 1)
14068 {
14069 /* PR 17531 file: 027-19978-0.004. */
14070 size_t maxlen = (end - p) - 1;
14071
14072 putchar ('"');
14073 if (maxlen > 0)
14074 {
14075 print_symbol ((int) maxlen, (const char *) p);
14076 p += strnlen ((char *) p, maxlen) + 1;
14077 }
14078 else
14079 {
14080 printf (_("<corrupt string tag>"));
14081 p = (unsigned char *) end;
14082 }
14083 printf ("\"\n");
14084 }
14085 else
14086 {
14087 unsigned int len;
14088
14089 val = read_uleb128 (p, &len, end);
14090 p += len;
14091 printf ("%ld (0x%lx)\n", val, val);
14092 }
14093
14094 assert (p <= end);
14095 return p;
14096}
14097
14098/* ARC ABI attributes section. */
14099
14100static unsigned char *
14101display_arc_attribute (unsigned char * p,
14102 const unsigned char * const end)
14103{
14104 unsigned int tag;
14105 unsigned int len;
14106 unsigned int val;
14107
14108 tag = read_uleb128 (p, &len, end);
14109 p += len;
14110
14111 switch (tag)
14112 {
14113 case Tag_ARC_PCS_config:
14114 val = read_uleb128 (p, &len, end);
14115 p += len;
14116 printf (" Tag_ARC_PCS_config: ");
14117 switch (val)
14118 {
14119 case 0:
14120 printf (_("Absent/Non standard\n"));
14121 break;
14122 case 1:
14123 printf (_("Bare metal/mwdt\n"));
14124 break;
14125 case 2:
14126 printf (_("Bare metal/newlib\n"));
14127 break;
14128 case 3:
14129 printf (_("Linux/uclibc\n"));
14130 break;
14131 case 4:
14132 printf (_("Linux/glibc\n"));
14133 break;
14134 default:
14135 printf (_("Unknown\n"));
14136 break;
14137 }
14138 break;
14139
14140 case Tag_ARC_CPU_base:
14141 val = read_uleb128 (p, &len, end);
14142 p += len;
14143 printf (" Tag_ARC_CPU_base: ");
14144 switch (val)
14145 {
14146 default:
14147 case TAG_CPU_NONE:
14148 printf (_("Absent\n"));
14149 break;
14150 case TAG_CPU_ARC6xx:
14151 printf ("ARC6xx\n");
14152 break;
14153 case TAG_CPU_ARC7xx:
14154 printf ("ARC7xx\n");
14155 break;
14156 case TAG_CPU_ARCEM:
14157 printf ("ARCEM\n");
14158 break;
14159 case TAG_CPU_ARCHS:
14160 printf ("ARCHS\n");
14161 break;
14162 }
14163 break;
14164
14165 case Tag_ARC_CPU_variation:
14166 val = read_uleb128 (p, &len, end);
14167 p += len;
14168 printf (" Tag_ARC_CPU_variation: ");
14169 switch (val)
14170 {
14171 default:
14172 if (val > 0 && val < 16)
14173 printf ("Core%d\n", val);
14174 else
14175 printf ("Unknown\n");
14176 break;
14177
14178 case 0:
14179 printf (_("Absent\n"));
14180 break;
14181 }
14182 break;
14183
14184 case Tag_ARC_CPU_name:
14185 printf (" Tag_ARC_CPU_name: ");
14186 p = display_tag_value (-1, p, end);
14187 break;
14188
14189 case Tag_ARC_ABI_rf16:
14190 val = read_uleb128 (p, &len, end);
14191 p += len;
14192 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14193 break;
14194
14195 case Tag_ARC_ABI_osver:
14196 val = read_uleb128 (p, &len, end);
14197 p += len;
14198 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14199 break;
14200
14201 case Tag_ARC_ABI_pic:
14202 case Tag_ARC_ABI_sda:
14203 val = read_uleb128 (p, &len, end);
14204 p += len;
14205 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14206 : " Tag_ARC_ABI_pic: ");
14207 switch (val)
14208 {
14209 case 0:
14210 printf (_("Absent\n"));
14211 break;
14212 case 1:
14213 printf ("MWDT\n");
14214 break;
14215 case 2:
14216 printf ("GNU\n");
14217 break;
14218 default:
14219 printf (_("Unknown\n"));
14220 break;
14221 }
14222 break;
14223
14224 case Tag_ARC_ABI_tls:
14225 val = read_uleb128 (p, &len, end);
14226 p += len;
14227 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14228 break;
14229
14230 case Tag_ARC_ABI_enumsize:
14231 val = read_uleb128 (p, &len, end);
14232 p += len;
14233 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14234 _("smallest"));
14235 break;
14236
14237 case Tag_ARC_ABI_exceptions:
14238 val = read_uleb128 (p, &len, end);
14239 p += len;
14240 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14241 : _("default"));
14242 break;
14243
14244 case Tag_ARC_ABI_double_size:
14245 val = read_uleb128 (p, &len, end);
14246 p += len;
14247 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14248 break;
14249
14250 case Tag_ARC_ISA_config:
14251 printf (" Tag_ARC_ISA_config: ");
14252 p = display_tag_value (-1, p, end);
14253 break;
14254
14255 case Tag_ARC_ISA_apex:
14256 printf (" Tag_ARC_ISA_apex: ");
14257 p = display_tag_value (-1, p, end);
14258 break;
14259
14260 case Tag_ARC_ISA_mpy_option:
14261 val = read_uleb128 (p, &len, end);
14262 p += len;
14263 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14264 break;
14265
14266 case Tag_ARC_ATR_version:
14267 val = read_uleb128 (p, &len, end);
14268 p += len;
14269 printf (" Tag_ARC_ATR_version: %d\n", val);
14270 break;
14271
14272 default:
14273 return display_tag_value (tag & 1, p, end);
14274 }
14275
14276 return p;
14277}
14278
14279/* ARM EABI attributes section. */
14280typedef struct
14281{
14282 unsigned int tag;
14283 const char * name;
14284 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14285 unsigned int type;
14286 const char ** table;
14287} arm_attr_public_tag;
14288
14289static const char * arm_attr_tag_CPU_arch[] =
14290 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14291 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14292 "v8-M.mainline"};
14293static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14294static const char * arm_attr_tag_THUMB_ISA_use[] =
14295 {"No", "Thumb-1", "Thumb-2", "Yes"};
14296static const char * arm_attr_tag_FP_arch[] =
14297 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14298 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14299static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14300static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14301 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14302 "NEON for ARMv8.1"};
14303static const char * arm_attr_tag_PCS_config[] =
14304 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14305 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14306static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14307 {"V6", "SB", "TLS", "Unused"};
14308static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14309 {"Absolute", "PC-relative", "SB-relative", "None"};
14310static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14311 {"Absolute", "PC-relative", "None"};
14312static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14313 {"None", "direct", "GOT-indirect"};
14314static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14315 {"None", "??? 1", "2", "??? 3", "4"};
14316static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14317static const char * arm_attr_tag_ABI_FP_denormal[] =
14318 {"Unused", "Needed", "Sign only"};
14319static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14320static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14321static const char * arm_attr_tag_ABI_FP_number_model[] =
14322 {"Unused", "Finite", "RTABI", "IEEE 754"};
14323static const char * arm_attr_tag_ABI_enum_size[] =
14324 {"Unused", "small", "int", "forced to int"};
14325static const char * arm_attr_tag_ABI_HardFP_use[] =
14326 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14327static const char * arm_attr_tag_ABI_VFP_args[] =
14328 {"AAPCS", "VFP registers", "custom", "compatible"};
14329static const char * arm_attr_tag_ABI_WMMX_args[] =
14330 {"AAPCS", "WMMX registers", "custom"};
14331static const char * arm_attr_tag_ABI_optimization_goals[] =
14332 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14333 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14334static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14335 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14336 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14337static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14338static const char * arm_attr_tag_FP_HP_extension[] =
14339 {"Not Allowed", "Allowed"};
14340static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14341 {"None", "IEEE 754", "Alternative Format"};
14342static const char * arm_attr_tag_DSP_extension[] =
14343 {"Follow architecture", "Allowed"};
14344static const char * arm_attr_tag_MPextension_use[] =
14345 {"Not Allowed", "Allowed"};
14346static const char * arm_attr_tag_DIV_use[] =
14347 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14348 "Allowed in v7-A with integer division extension"};
14349static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14350static const char * arm_attr_tag_Virtualization_use[] =
14351 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14352 "TrustZone and Virtualization Extensions"};
14353static const char * arm_attr_tag_MPextension_use_legacy[] =
14354 {"Not Allowed", "Allowed"};
14355
14356#define LOOKUP(id, name) \
14357 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14358static arm_attr_public_tag arm_attr_public_tags[] =
14359{
14360 {4, "CPU_raw_name", 1, NULL},
14361 {5, "CPU_name", 1, NULL},
14362 LOOKUP(6, CPU_arch),
14363 {7, "CPU_arch_profile", 0, NULL},
14364 LOOKUP(8, ARM_ISA_use),
14365 LOOKUP(9, THUMB_ISA_use),
14366 LOOKUP(10, FP_arch),
14367 LOOKUP(11, WMMX_arch),
14368 LOOKUP(12, Advanced_SIMD_arch),
14369 LOOKUP(13, PCS_config),
14370 LOOKUP(14, ABI_PCS_R9_use),
14371 LOOKUP(15, ABI_PCS_RW_data),
14372 LOOKUP(16, ABI_PCS_RO_data),
14373 LOOKUP(17, ABI_PCS_GOT_use),
14374 LOOKUP(18, ABI_PCS_wchar_t),
14375 LOOKUP(19, ABI_FP_rounding),
14376 LOOKUP(20, ABI_FP_denormal),
14377 LOOKUP(21, ABI_FP_exceptions),
14378 LOOKUP(22, ABI_FP_user_exceptions),
14379 LOOKUP(23, ABI_FP_number_model),
14380 {24, "ABI_align_needed", 0, NULL},
14381 {25, "ABI_align_preserved", 0, NULL},
14382 LOOKUP(26, ABI_enum_size),
14383 LOOKUP(27, ABI_HardFP_use),
14384 LOOKUP(28, ABI_VFP_args),
14385 LOOKUP(29, ABI_WMMX_args),
14386 LOOKUP(30, ABI_optimization_goals),
14387 LOOKUP(31, ABI_FP_optimization_goals),
14388 {32, "compatibility", 0, NULL},
14389 LOOKUP(34, CPU_unaligned_access),
14390 LOOKUP(36, FP_HP_extension),
14391 LOOKUP(38, ABI_FP_16bit_format),
14392 LOOKUP(42, MPextension_use),
14393 LOOKUP(44, DIV_use),
14394 LOOKUP(46, DSP_extension),
14395 {64, "nodefaults", 0, NULL},
14396 {65, "also_compatible_with", 0, NULL},
14397 LOOKUP(66, T2EE_use),
14398 {67, "conformance", 1, NULL},
14399 LOOKUP(68, Virtualization_use),
14400 LOOKUP(70, MPextension_use_legacy)
14401};
14402#undef LOOKUP
14403
14404static unsigned char *
14405display_arm_attribute (unsigned char * p,
14406 const unsigned char * const end)
14407{
14408 unsigned int tag;
14409 unsigned int len;
14410 unsigned int val;
14411 arm_attr_public_tag * attr;
14412 unsigned i;
14413 unsigned int type;
14414
14415 tag = read_uleb128 (p, &len, end);
14416 p += len;
14417 attr = NULL;
14418 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14419 {
14420 if (arm_attr_public_tags[i].tag == tag)
14421 {
14422 attr = &arm_attr_public_tags[i];
14423 break;
14424 }
14425 }
14426
14427 if (attr)
14428 {
14429 printf (" Tag_%s: ", attr->name);
14430 switch (attr->type)
14431 {
14432 case 0:
14433 switch (tag)
14434 {
14435 case 7: /* Tag_CPU_arch_profile. */
14436 val = read_uleb128 (p, &len, end);
14437 p += len;
14438 switch (val)
14439 {
14440 case 0: printf (_("None\n")); break;
14441 case 'A': printf (_("Application\n")); break;
14442 case 'R': printf (_("Realtime\n")); break;
14443 case 'M': printf (_("Microcontroller\n")); break;
14444 case 'S': printf (_("Application or Realtime\n")); break;
14445 default: printf ("??? (%d)\n", val); break;
14446 }
14447 break;
14448
14449 case 24: /* Tag_align_needed. */
14450 val = read_uleb128 (p, &len, end);
14451 p += len;
14452 switch (val)
14453 {
14454 case 0: printf (_("None\n")); break;
14455 case 1: printf (_("8-byte\n")); break;
14456 case 2: printf (_("4-byte\n")); break;
14457 case 3: printf ("??? 3\n"); break;
14458 default:
14459 if (val <= 12)
14460 printf (_("8-byte and up to %d-byte extended\n"),
14461 1 << val);
14462 else
14463 printf ("??? (%d)\n", val);
14464 break;
14465 }
14466 break;
14467
14468 case 25: /* Tag_align_preserved. */
14469 val = read_uleb128 (p, &len, end);
14470 p += len;
14471 switch (val)
14472 {
14473 case 0: printf (_("None\n")); break;
14474 case 1: printf (_("8-byte, except leaf SP\n")); break;
14475 case 2: printf (_("8-byte\n")); break;
14476 case 3: printf ("??? 3\n"); break;
14477 default:
14478 if (val <= 12)
14479 printf (_("8-byte and up to %d-byte extended\n"),
14480 1 << val);
14481 else
14482 printf ("??? (%d)\n", val);
14483 break;
14484 }
14485 break;
14486
14487 case 32: /* Tag_compatibility. */
14488 {
14489 val = read_uleb128 (p, &len, end);
14490 p += len;
14491 printf (_("flag = %d, vendor = "), val);
14492 if (p < end - 1)
14493 {
14494 size_t maxlen = (end - p) - 1;
14495
14496 print_symbol ((int) maxlen, (const char *) p);
14497 p += strnlen ((char *) p, maxlen) + 1;
14498 }
14499 else
14500 {
14501 printf (_("<corrupt>"));
14502 p = (unsigned char *) end;
14503 }
14504 putchar ('\n');
14505 }
14506 break;
14507
14508 case 64: /* Tag_nodefaults. */
14509 /* PR 17531: file: 001-505008-0.01. */
14510 if (p < end)
14511 p++;
14512 printf (_("True\n"));
14513 break;
14514
14515 case 65: /* Tag_also_compatible_with. */
14516 val = read_uleb128 (p, &len, end);
14517 p += len;
14518 if (val == 6 /* Tag_CPU_arch. */)
14519 {
14520 val = read_uleb128 (p, &len, end);
14521 p += len;
14522 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14523 printf ("??? (%d)\n", val);
14524 else
14525 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14526 }
14527 else
14528 printf ("???\n");
14529 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14530 ;
14531 break;
14532
14533 default:
14534 printf (_("<unknown: %d>\n"), tag);
14535 break;
14536 }
14537 return p;
14538
14539 case 1:
14540 return display_tag_value (-1, p, end);
14541 case 2:
14542 return display_tag_value (0, p, end);
14543
14544 default:
14545 assert (attr->type & 0x80);
14546 val = read_uleb128 (p, &len, end);
14547 p += len;
14548 type = attr->type & 0x7f;
14549 if (val >= type)
14550 printf ("??? (%d)\n", val);
14551 else
14552 printf ("%s\n", attr->table[val]);
14553 return p;
14554 }
14555 }
14556
14557 return display_tag_value (tag, p, end);
14558}
14559
14560static unsigned char *
14561display_gnu_attribute (unsigned char * p,
14562 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14563 const unsigned char * const end)
14564{
14565 int tag;
14566 unsigned int len;
14567 unsigned int val;
14568
14569 tag = read_uleb128 (p, &len, end);
14570 p += len;
14571
14572 /* Tag_compatibility is the only generic GNU attribute defined at
14573 present. */
14574 if (tag == 32)
14575 {
14576 val = read_uleb128 (p, &len, end);
14577 p += len;
14578
14579 printf (_("flag = %d, vendor = "), val);
14580 if (p == end)
14581 {
14582 printf (_("<corrupt>\n"));
14583 warn (_("corrupt vendor attribute\n"));
14584 }
14585 else
14586 {
14587 if (p < end - 1)
14588 {
14589 size_t maxlen = (end - p) - 1;
14590
14591 print_symbol ((int) maxlen, (const char *) p);
14592 p += strnlen ((char *) p, maxlen) + 1;
14593 }
14594 else
14595 {
14596 printf (_("<corrupt>"));
14597 p = (unsigned char *) end;
14598 }
14599 putchar ('\n');
14600 }
14601 return p;
14602 }
14603
14604 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14605 return display_proc_gnu_attribute (p, tag, end);
14606
14607 return display_tag_value (tag, p, end);
14608}
14609
14610static unsigned char *
14611display_power_gnu_attribute (unsigned char * p,
14612 unsigned int tag,
14613 const unsigned char * const end)
14614{
14615 unsigned int len;
14616 unsigned int val;
14617
14618 if (tag == Tag_GNU_Power_ABI_FP)
14619 {
14620 val = read_uleb128 (p, &len, end);
14621 p += len;
14622 printf (" Tag_GNU_Power_ABI_FP: ");
14623 if (len == 0)
14624 {
14625 printf (_("<corrupt>\n"));
14626 return p;
14627 }
14628
14629 if (val > 15)
14630 printf ("(%#x), ", val);
14631
14632 switch (val & 3)
14633 {
14634 case 0:
14635 printf (_("unspecified hard/soft float, "));
14636 break;
14637 case 1:
14638 printf (_("hard float, "));
14639 break;
14640 case 2:
14641 printf (_("soft float, "));
14642 break;
14643 case 3:
14644 printf (_("single-precision hard float, "));
14645 break;
14646 }
14647
14648 switch (val & 0xC)
14649 {
14650 case 0:
14651 printf (_("unspecified long double\n"));
14652 break;
14653 case 4:
14654 printf (_("128-bit IBM long double\n"));
14655 break;
14656 case 8:
14657 printf (_("64-bit long double\n"));
14658 break;
14659 case 12:
14660 printf (_("128-bit IEEE long double\n"));
14661 break;
14662 }
14663 return p;
14664 }
14665
14666 if (tag == Tag_GNU_Power_ABI_Vector)
14667 {
14668 val = read_uleb128 (p, &len, end);
14669 p += len;
14670 printf (" Tag_GNU_Power_ABI_Vector: ");
14671 if (len == 0)
14672 {
14673 printf (_("<corrupt>\n"));
14674 return p;
14675 }
14676
14677 if (val > 3)
14678 printf ("(%#x), ", val);
14679
14680 switch (val & 3)
14681 {
14682 case 0:
14683 printf (_("unspecified\n"));
14684 break;
14685 case 1:
14686 printf (_("generic\n"));
14687 break;
14688 case 2:
14689 printf ("AltiVec\n");
14690 break;
14691 case 3:
14692 printf ("SPE\n");
14693 break;
14694 }
14695 return p;
14696 }
14697
14698 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14699 {
14700 val = read_uleb128 (p, &len, end);
14701 p += len;
14702 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14703 if (len == 0)
14704 {
14705 printf (_("<corrupt>\n"));
14706 return p;
14707 }
14708
14709 if (val > 2)
14710 printf ("(%#x), ", val);
14711
14712 switch (val & 3)
14713 {
14714 case 0:
14715 printf (_("unspecified\n"));
14716 break;
14717 case 1:
14718 printf ("r3/r4\n");
14719 break;
14720 case 2:
14721 printf (_("memory\n"));
14722 break;
14723 case 3:
14724 printf ("???\n");
14725 break;
14726 }
14727 return p;
14728 }
14729
14730 return display_tag_value (tag & 1, p, end);
14731}
14732
14733static unsigned char *
14734display_s390_gnu_attribute (unsigned char * p,
14735 unsigned int tag,
14736 const unsigned char * const end)
14737{
14738 unsigned int len;
14739 int val;
14740
14741 if (tag == Tag_GNU_S390_ABI_Vector)
14742 {
14743 val = read_uleb128 (p, &len, end);
14744 p += len;
14745 printf (" Tag_GNU_S390_ABI_Vector: ");
14746
14747 switch (val)
14748 {
14749 case 0:
14750 printf (_("any\n"));
14751 break;
14752 case 1:
14753 printf (_("software\n"));
14754 break;
14755 case 2:
14756 printf (_("hardware\n"));
14757 break;
14758 default:
14759 printf ("??? (%d)\n", val);
14760 break;
14761 }
14762 return p;
14763 }
14764
14765 return display_tag_value (tag & 1, p, end);
14766}
14767
14768static void
14769display_sparc_hwcaps (unsigned int mask)
14770{
14771 if (mask)
14772 {
14773 bfd_boolean first = TRUE;
14774
14775 if (mask & ELF_SPARC_HWCAP_MUL32)
14776 fputs ("mul32", stdout), first = FALSE;
14777 if (mask & ELF_SPARC_HWCAP_DIV32)
14778 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14779 if (mask & ELF_SPARC_HWCAP_FSMULD)
14780 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14781 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14782 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14783 if (mask & ELF_SPARC_HWCAP_POPC)
14784 printf ("%spopc", first ? "" : "|"), first = FALSE;
14785 if (mask & ELF_SPARC_HWCAP_VIS)
14786 printf ("%svis", first ? "" : "|"), first = FALSE;
14787 if (mask & ELF_SPARC_HWCAP_VIS2)
14788 printf ("%svis2", first ? "" : "|"), first = FALSE;
14789 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14790 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14791 if (mask & ELF_SPARC_HWCAP_FMAF)
14792 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14793 if (mask & ELF_SPARC_HWCAP_VIS3)
14794 printf ("%svis3", first ? "" : "|"), first = FALSE;
14795 if (mask & ELF_SPARC_HWCAP_HPC)
14796 printf ("%shpc", first ? "" : "|"), first = FALSE;
14797 if (mask & ELF_SPARC_HWCAP_RANDOM)
14798 printf ("%srandom", first ? "" : "|"), first = FALSE;
14799 if (mask & ELF_SPARC_HWCAP_TRANS)
14800 printf ("%strans", first ? "" : "|"), first = FALSE;
14801 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14802 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14803 if (mask & ELF_SPARC_HWCAP_IMA)
14804 printf ("%sima", first ? "" : "|"), first = FALSE;
14805 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14806 printf ("%scspare", first ? "" : "|"), first = FALSE;
14807 }
14808 else
14809 fputc ('0', stdout);
14810 fputc ('\n', stdout);
14811}
14812
14813static void
14814display_sparc_hwcaps2 (unsigned int mask)
14815{
14816 if (mask)
14817 {
14818 bfd_boolean first = TRUE;
14819
14820 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14821 fputs ("fjathplus", stdout), first = FALSE;
14822 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14823 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14824 if (mask & ELF_SPARC_HWCAP2_ADP)
14825 printf ("%sadp", first ? "" : "|"), first = FALSE;
14826 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14827 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14828 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14829 printf ("%smwait", first ? "" : "|"), first = FALSE;
14830 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14831 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14832 if (mask & ELF_SPARC_HWCAP2_XMONT)
14833 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14834 if (mask & ELF_SPARC_HWCAP2_NSEC)
14835 printf ("%snsec", first ? "" : "|"), first = FALSE;
14836 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14837 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14838 if (mask & ELF_SPARC_HWCAP2_FJDES)
14839 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14840 if (mask & ELF_SPARC_HWCAP2_FJAES)
14841 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14842 }
14843 else
14844 fputc ('0', stdout);
14845 fputc ('\n', stdout);
14846}
14847
14848static unsigned char *
14849display_sparc_gnu_attribute (unsigned char * p,
14850 unsigned int tag,
14851 const unsigned char * const end)
14852{
14853 unsigned int len;
14854 int val;
14855
14856 if (tag == Tag_GNU_Sparc_HWCAPS)
14857 {
14858 val = read_uleb128 (p, &len, end);
14859 p += len;
14860 printf (" Tag_GNU_Sparc_HWCAPS: ");
14861 display_sparc_hwcaps (val);
14862 return p;
14863 }
14864 if (tag == Tag_GNU_Sparc_HWCAPS2)
14865 {
14866 val = read_uleb128 (p, &len, end);
14867 p += len;
14868 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14869 display_sparc_hwcaps2 (val);
14870 return p;
14871 }
14872
14873 return display_tag_value (tag, p, end);
14874}
14875
14876static void
14877print_mips_fp_abi_value (unsigned int val)
14878{
14879 switch (val)
14880 {
14881 case Val_GNU_MIPS_ABI_FP_ANY:
14882 printf (_("Hard or soft float\n"));
14883 break;
14884 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14885 printf (_("Hard float (double precision)\n"));
14886 break;
14887 case Val_GNU_MIPS_ABI_FP_SINGLE:
14888 printf (_("Hard float (single precision)\n"));
14889 break;
14890 case Val_GNU_MIPS_ABI_FP_SOFT:
14891 printf (_("Soft float\n"));
14892 break;
14893 case Val_GNU_MIPS_ABI_FP_OLD_64:
14894 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14895 break;
14896 case Val_GNU_MIPS_ABI_FP_XX:
14897 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14898 break;
14899 case Val_GNU_MIPS_ABI_FP_64:
14900 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14901 break;
14902 case Val_GNU_MIPS_ABI_FP_64A:
14903 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14904 break;
14905 case Val_GNU_MIPS_ABI_FP_NAN2008:
14906 printf (_("NaN 2008 compatibility\n"));
14907 break;
14908 default:
14909 printf ("??? (%d)\n", val);
14910 break;
14911 }
14912}
14913
14914static unsigned char *
14915display_mips_gnu_attribute (unsigned char * p,
14916 unsigned int tag,
14917 const unsigned char * const end)
14918{
14919 if (tag == Tag_GNU_MIPS_ABI_FP)
14920 {
14921 unsigned int len;
14922 unsigned int val;
14923
14924 val = read_uleb128 (p, &len, end);
14925 p += len;
14926 printf (" Tag_GNU_MIPS_ABI_FP: ");
14927
14928 print_mips_fp_abi_value (val);
14929
14930 return p;
14931 }
14932
14933 if (tag == Tag_GNU_MIPS_ABI_MSA)
14934 {
14935 unsigned int len;
14936 unsigned int val;
14937
14938 val = read_uleb128 (p, &len, end);
14939 p += len;
14940 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14941
14942 switch (val)
14943 {
14944 case Val_GNU_MIPS_ABI_MSA_ANY:
14945 printf (_("Any MSA or not\n"));
14946 break;
14947 case Val_GNU_MIPS_ABI_MSA_128:
14948 printf (_("128-bit MSA\n"));
14949 break;
14950 default:
14951 printf ("??? (%d)\n", val);
14952 break;
14953 }
14954 return p;
14955 }
14956
14957 return display_tag_value (tag & 1, p, end);
14958}
14959
14960static unsigned char *
14961display_tic6x_attribute (unsigned char * p,
14962 const unsigned char * const end)
14963{
14964 unsigned int tag;
14965 unsigned int len;
14966 int val;
14967
14968 tag = read_uleb128 (p, &len, end);
14969 p += len;
14970
14971 switch (tag)
14972 {
14973 case Tag_ISA:
14974 val = read_uleb128 (p, &len, end);
14975 p += len;
14976 printf (" Tag_ISA: ");
14977
14978 switch (val)
14979 {
14980 case C6XABI_Tag_ISA_none:
14981 printf (_("None\n"));
14982 break;
14983 case C6XABI_Tag_ISA_C62X:
14984 printf ("C62x\n");
14985 break;
14986 case C6XABI_Tag_ISA_C67X:
14987 printf ("C67x\n");
14988 break;
14989 case C6XABI_Tag_ISA_C67XP:
14990 printf ("C67x+\n");
14991 break;
14992 case C6XABI_Tag_ISA_C64X:
14993 printf ("C64x\n");
14994 break;
14995 case C6XABI_Tag_ISA_C64XP:
14996 printf ("C64x+\n");
14997 break;
14998 case C6XABI_Tag_ISA_C674X:
14999 printf ("C674x\n");
15000 break;
15001 default:
15002 printf ("??? (%d)\n", val);
15003 break;
15004 }
15005 return p;
15006
15007 case Tag_ABI_wchar_t:
15008 val = read_uleb128 (p, &len, end);
15009 p += len;
15010 printf (" Tag_ABI_wchar_t: ");
15011 switch (val)
15012 {
15013 case 0:
15014 printf (_("Not used\n"));
15015 break;
15016 case 1:
15017 printf (_("2 bytes\n"));
15018 break;
15019 case 2:
15020 printf (_("4 bytes\n"));
15021 break;
15022 default:
15023 printf ("??? (%d)\n", val);
15024 break;
15025 }
15026 return p;
15027
15028 case Tag_ABI_stack_align_needed:
15029 val = read_uleb128 (p, &len, end);
15030 p += len;
15031 printf (" Tag_ABI_stack_align_needed: ");
15032 switch (val)
15033 {
15034 case 0:
15035 printf (_("8-byte\n"));
15036 break;
15037 case 1:
15038 printf (_("16-byte\n"));
15039 break;
15040 default:
15041 printf ("??? (%d)\n", val);
15042 break;
15043 }
15044 return p;
15045
15046 case Tag_ABI_stack_align_preserved:
15047 val = read_uleb128 (p, &len, end);
15048 p += len;
15049 printf (" Tag_ABI_stack_align_preserved: ");
15050 switch (val)
15051 {
15052 case 0:
15053 printf (_("8-byte\n"));
15054 break;
15055 case 1:
15056 printf (_("16-byte\n"));
15057 break;
15058 default:
15059 printf ("??? (%d)\n", val);
15060 break;
15061 }
15062 return p;
15063
15064 case Tag_ABI_DSBT:
15065 val = read_uleb128 (p, &len, end);
15066 p += len;
15067 printf (" Tag_ABI_DSBT: ");
15068 switch (val)
15069 {
15070 case 0:
15071 printf (_("DSBT addressing not used\n"));
15072 break;
15073 case 1:
15074 printf (_("DSBT addressing used\n"));
15075 break;
15076 default:
15077 printf ("??? (%d)\n", val);
15078 break;
15079 }
15080 return p;
15081
15082 case Tag_ABI_PID:
15083 val = read_uleb128 (p, &len, end);
15084 p += len;
15085 printf (" Tag_ABI_PID: ");
15086 switch (val)
15087 {
15088 case 0:
15089 printf (_("Data addressing position-dependent\n"));
15090 break;
15091 case 1:
15092 printf (_("Data addressing position-independent, GOT near DP\n"));
15093 break;
15094 case 2:
15095 printf (_("Data addressing position-independent, GOT far from DP\n"));
15096 break;
15097 default:
15098 printf ("??? (%d)\n", val);
15099 break;
15100 }
15101 return p;
15102
15103 case Tag_ABI_PIC:
15104 val = read_uleb128 (p, &len, end);
15105 p += len;
15106 printf (" Tag_ABI_PIC: ");
15107 switch (val)
15108 {
15109 case 0:
15110 printf (_("Code addressing position-dependent\n"));
15111 break;
15112 case 1:
15113 printf (_("Code addressing position-independent\n"));
15114 break;
15115 default:
15116 printf ("??? (%d)\n", val);
15117 break;
15118 }
15119 return p;
15120
15121 case Tag_ABI_array_object_alignment:
15122 val = read_uleb128 (p, &len, end);
15123 p += len;
15124 printf (" Tag_ABI_array_object_alignment: ");
15125 switch (val)
15126 {
15127 case 0:
15128 printf (_("8-byte\n"));
15129 break;
15130 case 1:
15131 printf (_("4-byte\n"));
15132 break;
15133 case 2:
15134 printf (_("16-byte\n"));
15135 break;
15136 default:
15137 printf ("??? (%d)\n", val);
15138 break;
15139 }
15140 return p;
15141
15142 case Tag_ABI_array_object_align_expected:
15143 val = read_uleb128 (p, &len, end);
15144 p += len;
15145 printf (" Tag_ABI_array_object_align_expected: ");
15146 switch (val)
15147 {
15148 case 0:
15149 printf (_("8-byte\n"));
15150 break;
15151 case 1:
15152 printf (_("4-byte\n"));
15153 break;
15154 case 2:
15155 printf (_("16-byte\n"));
15156 break;
15157 default:
15158 printf ("??? (%d)\n", val);
15159 break;
15160 }
15161 return p;
15162
15163 case Tag_ABI_compatibility:
15164 {
15165 val = read_uleb128 (p, &len, end);
15166 p += len;
15167 printf (" Tag_ABI_compatibility: ");
15168 printf (_("flag = %d, vendor = "), val);
15169 if (p < end - 1)
15170 {
15171 size_t maxlen = (end - p) - 1;
15172
15173 print_symbol ((int) maxlen, (const char *) p);
15174 p += strnlen ((char *) p, maxlen) + 1;
15175 }
15176 else
15177 {
15178 printf (_("<corrupt>"));
15179 p = (unsigned char *) end;
15180 }
15181 putchar ('\n');
15182 return p;
15183 }
15184
15185 case Tag_ABI_conformance:
15186 {
15187 printf (" Tag_ABI_conformance: \"");
15188 if (p < end - 1)
15189 {
15190 size_t maxlen = (end - p) - 1;
15191
15192 print_symbol ((int) maxlen, (const char *) p);
15193 p += strnlen ((char *) p, maxlen) + 1;
15194 }
15195 else
15196 {
15197 printf (_("<corrupt>"));
15198 p = (unsigned char *) end;
15199 }
15200 printf ("\"\n");
15201 return p;
15202 }
15203 }
15204
15205 return display_tag_value (tag, p, end);
15206}
15207
15208static void
15209display_raw_attribute (unsigned char * p, unsigned char const * const end)
15210{
15211 unsigned long addr = 0;
15212 size_t bytes = end - p;
15213
15214 assert (end > p);
15215 while (bytes)
15216 {
15217 int j;
15218 int k;
15219 int lbytes = (bytes > 16 ? 16 : bytes);
15220
15221 printf (" 0x%8.8lx ", addr);
15222
15223 for (j = 0; j < 16; j++)
15224 {
15225 if (j < lbytes)
15226 printf ("%2.2x", p[j]);
15227 else
15228 printf (" ");
15229
15230 if ((j & 3) == 3)
15231 printf (" ");
15232 }
15233
15234 for (j = 0; j < lbytes; j++)
15235 {
15236 k = p[j];
15237 if (k >= ' ' && k < 0x7f)
15238 printf ("%c", k);
15239 else
15240 printf (".");
15241 }
15242
15243 putchar ('\n');
15244
15245 p += lbytes;
15246 bytes -= lbytes;
15247 addr += lbytes;
15248 }
15249
15250 putchar ('\n');
15251}
15252
15253static unsigned char *
15254display_msp430x_attribute (unsigned char * p,
15255 const unsigned char * const end)
15256{
15257 unsigned int len;
15258 unsigned int val;
15259 unsigned int tag;
15260
15261 tag = read_uleb128 (p, & len, end);
15262 p += len;
15263
15264 switch (tag)
15265 {
15266 case OFBA_MSPABI_Tag_ISA:
15267 val = read_uleb128 (p, &len, end);
15268 p += len;
15269 printf (" Tag_ISA: ");
15270 switch (val)
15271 {
15272 case 0: printf (_("None\n")); break;
15273 case 1: printf (_("MSP430\n")); break;
15274 case 2: printf (_("MSP430X\n")); break;
15275 default: printf ("??? (%d)\n", val); break;
15276 }
15277 break;
15278
15279 case OFBA_MSPABI_Tag_Code_Model:
15280 val = read_uleb128 (p, &len, end);
15281 p += len;
15282 printf (" Tag_Code_Model: ");
15283 switch (val)
15284 {
15285 case 0: printf (_("None\n")); break;
15286 case 1: printf (_("Small\n")); break;
15287 case 2: printf (_("Large\n")); break;
15288 default: printf ("??? (%d)\n", val); break;
15289 }
15290 break;
15291
15292 case OFBA_MSPABI_Tag_Data_Model:
15293 val = read_uleb128 (p, &len, end);
15294 p += len;
15295 printf (" Tag_Data_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 case 3: printf (_("Restricted Large\n")); break;
15302 default: printf ("??? (%d)\n", val); break;
15303 }
15304 break;
15305
15306 default:
15307 printf (_(" <unknown tag %d>: "), tag);
15308
15309 if (tag & 1)
15310 {
15311 putchar ('"');
15312 if (p < end - 1)
15313 {
15314 size_t maxlen = (end - p) - 1;
15315
15316 print_symbol ((int) maxlen, (const char *) p);
15317 p += strnlen ((char *) p, maxlen) + 1;
15318 }
15319 else
15320 {
15321 printf (_("<corrupt>"));
15322 p = (unsigned char *) end;
15323 }
15324 printf ("\"\n");
15325 }
15326 else
15327 {
15328 val = read_uleb128 (p, &len, end);
15329 p += len;
15330 printf ("%d (0x%x)\n", val, val);
15331 }
15332 break;
15333 }
15334
15335 assert (p <= end);
15336 return p;
15337}
15338
15339static bfd_boolean
15340process_attributes (Filedata * filedata,
15341 const char * public_name,
15342 unsigned int proc_type,
15343 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15344 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15345{
15346 Elf_Internal_Shdr * sect;
15347 unsigned i;
15348 bfd_boolean res = TRUE;
15349
15350 /* Find the section header so that we get the size. */
15351 for (i = 0, sect = filedata->section_headers;
15352 i < filedata->file_header.e_shnum;
15353 i++, sect++)
15354 {
15355 unsigned char * contents;
15356 unsigned char * p;
15357
15358 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15359 continue;
15360
15361 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15362 sect->sh_size, _("attributes"));
15363 if (contents == NULL)
15364 {
15365 res = FALSE;
15366 continue;
15367 }
15368
15369 p = contents;
15370 /* The first character is the version of the attributes.
15371 Currently only version 1, (aka 'A') is recognised here. */
15372 if (*p != 'A')
15373 {
15374 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15375 res = FALSE;
15376 }
15377 else
15378 {
15379 bfd_vma section_len;
15380
15381 section_len = sect->sh_size - 1;
15382 p++;
15383
15384 while (section_len > 0)
15385 {
15386 bfd_vma attr_len;
15387 unsigned int namelen;
15388 bfd_boolean public_section;
15389 bfd_boolean gnu_section;
15390
15391 if (section_len <= 4)
15392 {
15393 error (_("Tag section ends prematurely\n"));
15394 res = FALSE;
15395 break;
15396 }
15397 attr_len = byte_get (p, 4);
15398 p += 4;
15399
15400 if (attr_len > section_len)
15401 {
15402 error (_("Bad attribute length (%u > %u)\n"),
15403 (unsigned) attr_len, (unsigned) section_len);
15404 attr_len = section_len;
15405 res = FALSE;
15406 }
15407 /* PR 17531: file: 001-101425-0.004 */
15408 else if (attr_len < 5)
15409 {
15410 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15411 res = FALSE;
15412 break;
15413 }
15414
15415 section_len -= attr_len;
15416 attr_len -= 4;
15417
15418 namelen = strnlen ((char *) p, attr_len) + 1;
15419 if (namelen == 0 || namelen >= attr_len)
15420 {
15421 error (_("Corrupt attribute section name\n"));
15422 res = FALSE;
15423 break;
15424 }
15425
15426 printf (_("Attribute Section: "));
15427 print_symbol (INT_MAX, (const char *) p);
15428 putchar ('\n');
15429
15430 if (public_name && streq ((char *) p, public_name))
15431 public_section = TRUE;
15432 else
15433 public_section = FALSE;
15434
15435 if (streq ((char *) p, "gnu"))
15436 gnu_section = TRUE;
15437 else
15438 gnu_section = FALSE;
15439
15440 p += namelen;
15441 attr_len -= namelen;
15442
15443 while (attr_len > 0 && p < contents + sect->sh_size)
15444 {
15445 int tag;
15446 int val;
15447 bfd_vma size;
15448 unsigned char * end;
15449
15450 /* PR binutils/17531: Safe handling of corrupt files. */
15451 if (attr_len < 6)
15452 {
15453 error (_("Unused bytes at end of section\n"));
15454 res = FALSE;
15455 section_len = 0;
15456 break;
15457 }
15458
15459 tag = *(p++);
15460 size = byte_get (p, 4);
15461 if (size > attr_len)
15462 {
15463 error (_("Bad subsection length (%u > %u)\n"),
15464 (unsigned) size, (unsigned) attr_len);
15465 res = FALSE;
15466 size = attr_len;
15467 }
15468 /* PR binutils/17531: Safe handling of corrupt files. */
15469 if (size < 6)
15470 {
15471 error (_("Bad subsection length (%u < 6)\n"),
15472 (unsigned) size);
15473 res = FALSE;
15474 section_len = 0;
15475 break;
15476 }
15477
15478 attr_len -= size;
15479 end = p + size - 1;
15480 assert (end <= contents + sect->sh_size);
15481 p += 4;
15482
15483 switch (tag)
15484 {
15485 case 1:
15486 printf (_("File Attributes\n"));
15487 break;
15488 case 2:
15489 printf (_("Section Attributes:"));
15490 goto do_numlist;
15491 case 3:
15492 printf (_("Symbol Attributes:"));
15493 /* Fall through. */
15494 do_numlist:
15495 for (;;)
15496 {
15497 unsigned int j;
15498
15499 val = read_uleb128 (p, &j, end);
15500 p += j;
15501 if (val == 0)
15502 break;
15503 printf (" %d", val);
15504 }
15505 printf ("\n");
15506 break;
15507 default:
15508 printf (_("Unknown tag: %d\n"), tag);
15509 public_section = FALSE;
15510 break;
15511 }
15512
15513 if (public_section && display_pub_attribute != NULL)
15514 {
15515 while (p < end)
15516 p = display_pub_attribute (p, end);
15517 assert (p == end);
15518 }
15519 else if (gnu_section && display_proc_gnu_attribute != NULL)
15520 {
15521 while (p < end)
15522 p = display_gnu_attribute (p,
15523 display_proc_gnu_attribute,
15524 end);
15525 assert (p == end);
15526 }
15527 else if (p < end)
15528 {
15529 printf (_(" Unknown attribute:\n"));
15530 display_raw_attribute (p, end);
15531 p = end;
15532 }
15533 else
15534 attr_len = 0;
15535 }
15536 }
15537 }
15538
15539 free (contents);
15540 }
15541
15542 return res;
15543}
15544
15545/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15546 Print the Address, Access and Initial fields of an entry at VMA ADDR
15547 and return the VMA of the next entry, or -1 if there was a problem.
15548 Does not read from DATA_END or beyond. */
15549
15550static bfd_vma
15551print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15552 unsigned char * data_end)
15553{
15554 printf (" ");
15555 print_vma (addr, LONG_HEX);
15556 printf (" ");
15557 if (addr < pltgot + 0xfff0)
15558 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15559 else
15560 printf ("%10s", "");
15561 printf (" ");
15562 if (data == NULL)
15563 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15564 else
15565 {
15566 bfd_vma entry;
15567 unsigned char * from = data + addr - pltgot;
15568
15569 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15570 {
15571 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15572 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15573 return (bfd_vma) -1;
15574 }
15575 else
15576 {
15577 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15578 print_vma (entry, LONG_HEX);
15579 }
15580 }
15581 return addr + (is_32bit_elf ? 4 : 8);
15582}
15583
15584/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15585 PLTGOT. Print the Address and Initial fields of an entry at VMA
15586 ADDR and return the VMA of the next entry. */
15587
15588static bfd_vma
15589print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15590{
15591 printf (" ");
15592 print_vma (addr, LONG_HEX);
15593 printf (" ");
15594 if (data == NULL)
15595 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15596 else
15597 {
15598 bfd_vma entry;
15599
15600 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15601 print_vma (entry, LONG_HEX);
15602 }
15603 return addr + (is_32bit_elf ? 4 : 8);
15604}
15605
15606static void
15607print_mips_ases (unsigned int mask)
15608{
15609 if (mask & AFL_ASE_DSP)
15610 fputs ("\n\tDSP ASE", stdout);
15611 if (mask & AFL_ASE_DSPR2)
15612 fputs ("\n\tDSP R2 ASE", stdout);
15613 if (mask & AFL_ASE_DSPR3)
15614 fputs ("\n\tDSP R3 ASE", stdout);
15615 if (mask & AFL_ASE_EVA)
15616 fputs ("\n\tEnhanced VA Scheme", stdout);
15617 if (mask & AFL_ASE_MCU)
15618 fputs ("\n\tMCU (MicroController) ASE", stdout);
15619 if (mask & AFL_ASE_MDMX)
15620 fputs ("\n\tMDMX ASE", stdout);
15621 if (mask & AFL_ASE_MIPS3D)
15622 fputs ("\n\tMIPS-3D ASE", stdout);
15623 if (mask & AFL_ASE_MT)
15624 fputs ("\n\tMT ASE", stdout);
15625 if (mask & AFL_ASE_SMARTMIPS)
15626 fputs ("\n\tSmartMIPS ASE", stdout);
15627 if (mask & AFL_ASE_VIRT)
15628 fputs ("\n\tVZ ASE", stdout);
15629 if (mask & AFL_ASE_MSA)
15630 fputs ("\n\tMSA ASE", stdout);
15631 if (mask & AFL_ASE_MIPS16)
15632 fputs ("\n\tMIPS16 ASE", stdout);
15633 if (mask & AFL_ASE_MICROMIPS)
15634 fputs ("\n\tMICROMIPS ASE", stdout);
15635 if (mask & AFL_ASE_XPA)
15636 fputs ("\n\tXPA ASE", stdout);
15637 if (mask & AFL_ASE_MIPS16E2)
15638 fputs ("\n\tMIPS16e2 ASE", stdout);
15639 if (mask & AFL_ASE_CRC)
15640 fputs ("\n\tCRC ASE", stdout);
15641 if (mask & AFL_ASE_GINV)
15642 fputs ("\n\tGINV ASE", stdout);
15643 if (mask & AFL_ASE_LOONGSON_MMI)
15644 fputs ("\n\tLoongson MMI ASE", stdout);
15645 if (mask == 0)
15646 fprintf (stdout, "\n\t%s", _("None"));
15647 else if ((mask & ~AFL_ASE_MASK) != 0)
15648 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15649}
15650
15651static void
15652print_mips_isa_ext (unsigned int isa_ext)
15653{
15654 switch (isa_ext)
15655 {
15656 case 0:
15657 fputs (_("None"), stdout);
15658 break;
15659 case AFL_EXT_XLR:
15660 fputs ("RMI XLR", stdout);
15661 break;
15662 case AFL_EXT_OCTEON3:
15663 fputs ("Cavium Networks Octeon3", stdout);
15664 break;
15665 case AFL_EXT_OCTEON2:
15666 fputs ("Cavium Networks Octeon2", stdout);
15667 break;
15668 case AFL_EXT_OCTEONP:
15669 fputs ("Cavium Networks OcteonP", stdout);
15670 break;
15671 case AFL_EXT_LOONGSON_3A:
15672 fputs ("Loongson 3A", stdout);
15673 break;
15674 case AFL_EXT_OCTEON:
15675 fputs ("Cavium Networks Octeon", stdout);
15676 break;
15677 case AFL_EXT_5900:
15678 fputs ("Toshiba R5900", stdout);
15679 break;
15680 case AFL_EXT_4650:
15681 fputs ("MIPS R4650", stdout);
15682 break;
15683 case AFL_EXT_4010:
15684 fputs ("LSI R4010", stdout);
15685 break;
15686 case AFL_EXT_4100:
15687 fputs ("NEC VR4100", stdout);
15688 break;
15689 case AFL_EXT_3900:
15690 fputs ("Toshiba R3900", stdout);
15691 break;
15692 case AFL_EXT_10000:
15693 fputs ("MIPS R10000", stdout);
15694 break;
15695 case AFL_EXT_SB1:
15696 fputs ("Broadcom SB-1", stdout);
15697 break;
15698 case AFL_EXT_4111:
15699 fputs ("NEC VR4111/VR4181", stdout);
15700 break;
15701 case AFL_EXT_4120:
15702 fputs ("NEC VR4120", stdout);
15703 break;
15704 case AFL_EXT_5400:
15705 fputs ("NEC VR5400", stdout);
15706 break;
15707 case AFL_EXT_5500:
15708 fputs ("NEC VR5500", stdout);
15709 break;
15710 case AFL_EXT_LOONGSON_2E:
15711 fputs ("ST Microelectronics Loongson 2E", stdout);
15712 break;
15713 case AFL_EXT_LOONGSON_2F:
15714 fputs ("ST Microelectronics Loongson 2F", stdout);
15715 break;
15716 case AFL_EXT_INTERAPTIV_MR2:
15717 fputs ("Imagination interAptiv MR2", stdout);
15718 break;
15719 default:
15720 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15721 }
15722}
15723
15724static signed int
15725get_mips_reg_size (int reg_size)
15726{
15727 return (reg_size == AFL_REG_NONE) ? 0
15728 : (reg_size == AFL_REG_32) ? 32
15729 : (reg_size == AFL_REG_64) ? 64
15730 : (reg_size == AFL_REG_128) ? 128
15731 : -1;
15732}
15733
15734static bfd_boolean
15735process_mips_specific (Filedata * filedata)
15736{
15737 Elf_Internal_Dyn * entry;
15738 Elf_Internal_Shdr *sect = NULL;
15739 size_t liblist_offset = 0;
15740 size_t liblistno = 0;
15741 size_t conflictsno = 0;
15742 size_t options_offset = 0;
15743 size_t conflicts_offset = 0;
15744 size_t pltrelsz = 0;
15745 size_t pltrel = 0;
15746 bfd_vma pltgot = 0;
15747 bfd_vma mips_pltgot = 0;
15748 bfd_vma jmprel = 0;
15749 bfd_vma local_gotno = 0;
15750 bfd_vma gotsym = 0;
15751 bfd_vma symtabno = 0;
15752 bfd_boolean res = TRUE;
15753
15754 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15755 display_mips_gnu_attribute))
15756 res = FALSE;
15757
15758 sect = find_section (filedata, ".MIPS.abiflags");
15759
15760 if (sect != NULL)
15761 {
15762 Elf_External_ABIFlags_v0 *abiflags_ext;
15763 Elf_Internal_ABIFlags_v0 abiflags_in;
15764
15765 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15766 {
15767 error (_("Corrupt MIPS ABI Flags section.\n"));
15768 res = FALSE;
15769 }
15770 else
15771 {
15772 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15773 sect->sh_size, _("MIPS ABI Flags section"));
15774 if (abiflags_ext)
15775 {
15776 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15777 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15778 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15779 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15780 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15781 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15782 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15783 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15784 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15785 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15786 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15787
15788 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15789 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15790 if (abiflags_in.isa_rev > 1)
15791 printf ("r%d", abiflags_in.isa_rev);
15792 printf ("\nGPR size: %d",
15793 get_mips_reg_size (abiflags_in.gpr_size));
15794 printf ("\nCPR1 size: %d",
15795 get_mips_reg_size (abiflags_in.cpr1_size));
15796 printf ("\nCPR2 size: %d",
15797 get_mips_reg_size (abiflags_in.cpr2_size));
15798 fputs ("\nFP ABI: ", stdout);
15799 print_mips_fp_abi_value (abiflags_in.fp_abi);
15800 fputs ("ISA Extension: ", stdout);
15801 print_mips_isa_ext (abiflags_in.isa_ext);
15802 fputs ("\nASEs:", stdout);
15803 print_mips_ases (abiflags_in.ases);
15804 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15805 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15806 fputc ('\n', stdout);
15807 free (abiflags_ext);
15808 }
15809 }
15810 }
15811
15812 /* We have a lot of special sections. Thanks SGI! */
15813 if (dynamic_section == NULL)
15814 {
15815 /* No dynamic information available. See if there is static GOT. */
15816 sect = find_section (filedata, ".got");
15817 if (sect != NULL)
15818 {
15819 unsigned char *data_end;
15820 unsigned char *data;
15821 bfd_vma ent, end;
15822 int addr_size;
15823
15824 pltgot = sect->sh_addr;
15825
15826 ent = pltgot;
15827 addr_size = (is_32bit_elf ? 4 : 8);
15828 end = pltgot + sect->sh_size;
15829
15830 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15831 end - pltgot, 1,
15832 _("Global Offset Table data"));
15833 /* PR 12855: Null data is handled gracefully throughout. */
15834 data_end = data + (end - pltgot);
15835
15836 printf (_("\nStatic GOT:\n"));
15837 printf (_(" Canonical gp value: "));
15838 print_vma (ent + 0x7ff0, LONG_HEX);
15839 printf ("\n\n");
15840
15841 /* In a dynamic binary GOT[0] is reserved for the dynamic
15842 loader to store the lazy resolver pointer, however in
15843 a static binary it may well have been omitted and GOT
15844 reduced to a table of addresses.
15845 PR 21344: Check for the entry being fully available
15846 before fetching it. */
15847 if (data
15848 && data + ent - pltgot + addr_size <= data_end
15849 && byte_get (data + ent - pltgot, addr_size) == 0)
15850 {
15851 printf (_(" Reserved entries:\n"));
15852 printf (_(" %*s %10s %*s\n"),
15853 addr_size * 2, _("Address"), _("Access"),
15854 addr_size * 2, _("Value"));
15855 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15856 printf ("\n");
15857 if (ent == (bfd_vma) -1)
15858 goto sgot_print_fail;
15859
15860 /* Check for the MSB of GOT[1] being set, identifying a
15861 GNU object. This entry will be used by some runtime
15862 loaders, to store the module pointer. Otherwise this
15863 is an ordinary local entry.
15864 PR 21344: Check for the entry being fully available
15865 before fetching it. */
15866 if (data
15867 && data + ent - pltgot + addr_size <= data_end
15868 && (byte_get (data + ent - pltgot, addr_size)
15869 >> (addr_size * 8 - 1)) != 0)
15870 {
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 printf ("\n");
15877 }
15878
15879 if (data != NULL && ent < end)
15880 {
15881 printf (_(" Local entries:\n"));
15882 printf (" %*s %10s %*s\n",
15883 addr_size * 2, _("Address"), _("Access"),
15884 addr_size * 2, _("Value"));
15885 while (ent < end)
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 sgot_print_fail:
15896 if (data)
15897 free (data);
15898 }
15899 return res;
15900 }
15901
15902 for (entry = dynamic_section;
15903 /* PR 17531 file: 012-50589-0.004. */
15904 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15905 ++entry)
15906 switch (entry->d_tag)
15907 {
15908 case DT_MIPS_LIBLIST:
15909 liblist_offset
15910 = offset_from_vma (filedata, entry->d_un.d_val,
15911 liblistno * sizeof (Elf32_External_Lib));
15912 break;
15913 case DT_MIPS_LIBLISTNO:
15914 liblistno = entry->d_un.d_val;
15915 break;
15916 case DT_MIPS_OPTIONS:
15917 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15918 break;
15919 case DT_MIPS_CONFLICT:
15920 conflicts_offset
15921 = offset_from_vma (filedata, entry->d_un.d_val,
15922 conflictsno * sizeof (Elf32_External_Conflict));
15923 break;
15924 case DT_MIPS_CONFLICTNO:
15925 conflictsno = entry->d_un.d_val;
15926 break;
15927 case DT_PLTGOT:
15928 pltgot = entry->d_un.d_ptr;
15929 break;
15930 case DT_MIPS_LOCAL_GOTNO:
15931 local_gotno = entry->d_un.d_val;
15932 break;
15933 case DT_MIPS_GOTSYM:
15934 gotsym = entry->d_un.d_val;
15935 break;
15936 case DT_MIPS_SYMTABNO:
15937 symtabno = entry->d_un.d_val;
15938 break;
15939 case DT_MIPS_PLTGOT:
15940 mips_pltgot = entry->d_un.d_ptr;
15941 break;
15942 case DT_PLTREL:
15943 pltrel = entry->d_un.d_val;
15944 break;
15945 case DT_PLTRELSZ:
15946 pltrelsz = entry->d_un.d_val;
15947 break;
15948 case DT_JMPREL:
15949 jmprel = entry->d_un.d_ptr;
15950 break;
15951 default:
15952 break;
15953 }
15954
15955 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15956 {
15957 Elf32_External_Lib * elib;
15958 size_t cnt;
15959
15960 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15961 liblistno,
15962 sizeof (Elf32_External_Lib),
15963 _("liblist section data"));
15964 if (elib)
15965 {
15966 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15967 "\nSection '.liblist' contains %lu entries:\n",
15968 (unsigned long) liblistno),
15969 (unsigned long) liblistno);
15970 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15971 stdout);
15972
15973 for (cnt = 0; cnt < liblistno; ++cnt)
15974 {
15975 Elf32_Lib liblist;
15976 time_t atime;
15977 char timebuf[128];
15978 struct tm * tmp;
15979
15980 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15981 atime = BYTE_GET (elib[cnt].l_time_stamp);
15982 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15983 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15984 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15985
15986 tmp = gmtime (&atime);
15987 snprintf (timebuf, sizeof (timebuf),
15988 "%04u-%02u-%02uT%02u:%02u:%02u",
15989 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15990 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15991
15992 printf ("%3lu: ", (unsigned long) cnt);
15993 if (VALID_DYNAMIC_NAME (liblist.l_name))
15994 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15995 else
15996 printf (_("<corrupt: %9ld>"), liblist.l_name);
15997 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15998 liblist.l_version);
15999
16000 if (liblist.l_flags == 0)
16001 puts (_(" NONE"));
16002 else
16003 {
16004 static const struct
16005 {
16006 const char * name;
16007 int bit;
16008 }
16009 l_flags_vals[] =
16010 {
16011 { " EXACT_MATCH", LL_EXACT_MATCH },
16012 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16013 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16014 { " EXPORTS", LL_EXPORTS },
16015 { " DELAY_LOAD", LL_DELAY_LOAD },
16016 { " DELTA", LL_DELTA }
16017 };
16018 int flags = liblist.l_flags;
16019 size_t fcnt;
16020
16021 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16022 if ((flags & l_flags_vals[fcnt].bit) != 0)
16023 {
16024 fputs (l_flags_vals[fcnt].name, stdout);
16025 flags ^= l_flags_vals[fcnt].bit;
16026 }
16027 if (flags != 0)
16028 printf (" %#x", (unsigned int) flags);
16029
16030 puts ("");
16031 }
16032 }
16033
16034 free (elib);
16035 }
16036 else
16037 res = FALSE;
16038 }
16039
16040 if (options_offset != 0)
16041 {
16042 Elf_External_Options * eopt;
16043 Elf_Internal_Options * iopt;
16044 Elf_Internal_Options * option;
16045 size_t offset;
16046 int cnt;
16047 sect = filedata->section_headers;
16048
16049 /* Find the section header so that we get the size. */
16050 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16051 /* PR 17533 file: 012-277276-0.004. */
16052 if (sect == NULL)
16053 {
16054 error (_("No MIPS_OPTIONS header found\n"));
16055 return FALSE;
16056 }
16057
16058 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16059 sect->sh_size, _("options"));
16060 if (eopt)
16061 {
16062 iopt = (Elf_Internal_Options *)
16063 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16064 if (iopt == NULL)
16065 {
16066 error (_("Out of memory allocating space for MIPS options\n"));
16067 return FALSE;
16068 }
16069
16070 offset = cnt = 0;
16071 option = iopt;
16072
16073 while (offset <= sect->sh_size - sizeof (* eopt))
16074 {
16075 Elf_External_Options * eoption;
16076
16077 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16078
16079 option->kind = BYTE_GET (eoption->kind);
16080 option->size = BYTE_GET (eoption->size);
16081 option->section = BYTE_GET (eoption->section);
16082 option->info = BYTE_GET (eoption->info);
16083
16084 /* PR 17531: file: ffa0fa3b. */
16085 if (option->size < sizeof (* eopt)
16086 || offset + option->size > sect->sh_size)
16087 {
16088 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16089 return FALSE;
16090 }
16091 offset += option->size;
16092
16093 ++option;
16094 ++cnt;
16095 }
16096
16097 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16098 "\nSection '%s' contains %d entries:\n",
16099 cnt),
16100 printable_section_name (filedata, sect), cnt);
16101
16102 option = iopt;
16103 offset = 0;
16104
16105 while (cnt-- > 0)
16106 {
16107 size_t len;
16108
16109 switch (option->kind)
16110 {
16111 case ODK_NULL:
16112 /* This shouldn't happen. */
16113 printf (" NULL %d %lx", option->section, option->info);
16114 break;
16115 case ODK_REGINFO:
16116 printf (" REGINFO ");
16117 if (filedata->file_header.e_machine == EM_MIPS)
16118 {
16119 /* 32bit form. */
16120 Elf32_External_RegInfo * ereg;
16121 Elf32_RegInfo reginfo;
16122
16123 ereg = (Elf32_External_RegInfo *) (option + 1);
16124 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16125 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16126 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16127 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16128 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16129 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16130
16131 printf ("GPR %08lx GP 0x%lx\n",
16132 reginfo.ri_gprmask,
16133 (unsigned long) reginfo.ri_gp_value);
16134 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16135 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16136 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16137 }
16138 else
16139 {
16140 /* 64 bit form. */
16141 Elf64_External_RegInfo * ereg;
16142 Elf64_Internal_RegInfo reginfo;
16143
16144 ereg = (Elf64_External_RegInfo *) (option + 1);
16145 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16146 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16147 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16148 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16149 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16150 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16151
16152 printf ("GPR %08lx GP 0x",
16153 reginfo.ri_gprmask);
16154 printf_vma (reginfo.ri_gp_value);
16155 printf ("\n");
16156
16157 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16158 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16159 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16160 }
16161 ++option;
16162 continue;
16163 case ODK_EXCEPTIONS:
16164 fputs (" EXCEPTIONS fpe_min(", stdout);
16165 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16166 fputs (") fpe_max(", stdout);
16167 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16168 fputs (")", stdout);
16169
16170 if (option->info & OEX_PAGE0)
16171 fputs (" PAGE0", stdout);
16172 if (option->info & OEX_SMM)
16173 fputs (" SMM", stdout);
16174 if (option->info & OEX_FPDBUG)
16175 fputs (" FPDBUG", stdout);
16176 if (option->info & OEX_DISMISS)
16177 fputs (" DISMISS", stdout);
16178 break;
16179 case ODK_PAD:
16180 fputs (" PAD ", stdout);
16181 if (option->info & OPAD_PREFIX)
16182 fputs (" PREFIX", stdout);
16183 if (option->info & OPAD_POSTFIX)
16184 fputs (" POSTFIX", stdout);
16185 if (option->info & OPAD_SYMBOL)
16186 fputs (" SYMBOL", stdout);
16187 break;
16188 case ODK_HWPATCH:
16189 fputs (" HWPATCH ", stdout);
16190 if (option->info & OHW_R4KEOP)
16191 fputs (" R4KEOP", stdout);
16192 if (option->info & OHW_R8KPFETCH)
16193 fputs (" R8KPFETCH", stdout);
16194 if (option->info & OHW_R5KEOP)
16195 fputs (" R5KEOP", stdout);
16196 if (option->info & OHW_R5KCVTL)
16197 fputs (" R5KCVTL", stdout);
16198 break;
16199 case ODK_FILL:
16200 fputs (" FILL ", stdout);
16201 /* XXX Print content of info word? */
16202 break;
16203 case ODK_TAGS:
16204 fputs (" TAGS ", stdout);
16205 /* XXX Print content of info word? */
16206 break;
16207 case ODK_HWAND:
16208 fputs (" HWAND ", stdout);
16209 if (option->info & OHWA0_R4KEOP_CHECKED)
16210 fputs (" R4KEOP_CHECKED", stdout);
16211 if (option->info & OHWA0_R4KEOP_CLEAN)
16212 fputs (" R4KEOP_CLEAN", stdout);
16213 break;
16214 case ODK_HWOR:
16215 fputs (" HWOR ", stdout);
16216 if (option->info & OHWA0_R4KEOP_CHECKED)
16217 fputs (" R4KEOP_CHECKED", stdout);
16218 if (option->info & OHWA0_R4KEOP_CLEAN)
16219 fputs (" R4KEOP_CLEAN", stdout);
16220 break;
16221 case ODK_GP_GROUP:
16222 printf (" GP_GROUP %#06lx self-contained %#06lx",
16223 option->info & OGP_GROUP,
16224 (option->info & OGP_SELF) >> 16);
16225 break;
16226 case ODK_IDENT:
16227 printf (" IDENT %#06lx self-contained %#06lx",
16228 option->info & OGP_GROUP,
16229 (option->info & OGP_SELF) >> 16);
16230 break;
16231 default:
16232 /* This shouldn't happen. */
16233 printf (" %3d ??? %d %lx",
16234 option->kind, option->section, option->info);
16235 break;
16236 }
16237
16238 len = sizeof (* eopt);
16239 while (len < option->size)
16240 {
16241 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16242
16243 if (ISPRINT (datum))
16244 printf ("%c", datum);
16245 else
16246 printf ("\\%03o", datum);
16247 len ++;
16248 }
16249 fputs ("\n", stdout);
16250
16251 offset += option->size;
16252 ++option;
16253 }
16254
16255 free (eopt);
16256 }
16257 else
16258 res = FALSE;
16259 }
16260
16261 if (conflicts_offset != 0 && conflictsno != 0)
16262 {
16263 Elf32_Conflict * iconf;
16264 size_t cnt;
16265
16266 if (dynamic_symbols == NULL)
16267 {
16268 error (_("conflict list found without a dynamic symbol table\n"));
16269 return FALSE;
16270 }
16271
16272 /* PR 21345 - print a slightly more helpful error message
16273 if we are sure that the cmalloc will fail. */
16274 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16275 {
16276 error (_("Overlarge number of conflicts detected: %lx\n"),
16277 (long) conflictsno);
16278 return FALSE;
16279 }
16280
16281 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16282 if (iconf == NULL)
16283 {
16284 error (_("Out of memory allocating space for dynamic conflicts\n"));
16285 return FALSE;
16286 }
16287
16288 if (is_32bit_elf)
16289 {
16290 Elf32_External_Conflict * econf32;
16291
16292 econf32 = (Elf32_External_Conflict *)
16293 get_data (NULL, filedata, conflicts_offset, conflictsno,
16294 sizeof (* econf32), _("conflict"));
16295 if (!econf32)
16296 return FALSE;
16297
16298 for (cnt = 0; cnt < conflictsno; ++cnt)
16299 iconf[cnt] = BYTE_GET (econf32[cnt]);
16300
16301 free (econf32);
16302 }
16303 else
16304 {
16305 Elf64_External_Conflict * econf64;
16306
16307 econf64 = (Elf64_External_Conflict *)
16308 get_data (NULL, filedata, conflicts_offset, conflictsno,
16309 sizeof (* econf64), _("conflict"));
16310 if (!econf64)
16311 return FALSE;
16312
16313 for (cnt = 0; cnt < conflictsno; ++cnt)
16314 iconf[cnt] = BYTE_GET (econf64[cnt]);
16315
16316 free (econf64);
16317 }
16318
16319 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16320 "\nSection '.conflict' contains %lu entries:\n",
16321 (unsigned long) conflictsno),
16322 (unsigned long) conflictsno);
16323 puts (_(" Num: Index Value Name"));
16324
16325 for (cnt = 0; cnt < conflictsno; ++cnt)
16326 {
16327 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16328
16329 if (iconf[cnt] >= num_dynamic_syms)
16330 printf (_("<corrupt symbol index>"));
16331 else
16332 {
16333 Elf_Internal_Sym * psym;
16334
16335 psym = & dynamic_symbols[iconf[cnt]];
16336 print_vma (psym->st_value, FULL_HEX);
16337 putchar (' ');
16338 if (VALID_DYNAMIC_NAME (psym->st_name))
16339 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16340 else
16341 printf (_("<corrupt: %14ld>"), psym->st_name);
16342 }
16343 putchar ('\n');
16344 }
16345
16346 free (iconf);
16347 }
16348
16349 if (pltgot != 0 && local_gotno != 0)
16350 {
16351 bfd_vma ent, local_end, global_end;
16352 size_t i, offset;
16353 unsigned char * data;
16354 unsigned char * data_end;
16355 int addr_size;
16356
16357 ent = pltgot;
16358 addr_size = (is_32bit_elf ? 4 : 8);
16359 local_end = pltgot + local_gotno * addr_size;
16360
16361 /* PR binutils/17533 file: 012-111227-0.004 */
16362 if (symtabno < gotsym)
16363 {
16364 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16365 (unsigned long) gotsym, (unsigned long) symtabno);
16366 return FALSE;
16367 }
16368
16369 global_end = local_end + (symtabno - gotsym) * addr_size;
16370 /* PR 17531: file: 54c91a34. */
16371 if (global_end < local_end)
16372 {
16373 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16374 return FALSE;
16375 }
16376
16377 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16378 data = (unsigned char *) get_data (NULL, filedata, offset,
16379 global_end - pltgot, 1,
16380 _("Global Offset Table data"));
16381 /* PR 12855: Null data is handled gracefully throughout. */
16382 data_end = data + (global_end - pltgot);
16383
16384 printf (_("\nPrimary GOT:\n"));
16385 printf (_(" Canonical gp value: "));
16386 print_vma (pltgot + 0x7ff0, LONG_HEX);
16387 printf ("\n\n");
16388
16389 printf (_(" Reserved entries:\n"));
16390 printf (_(" %*s %10s %*s Purpose\n"),
16391 addr_size * 2, _("Address"), _("Access"),
16392 addr_size * 2, _("Initial"));
16393 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16394 printf (_(" Lazy resolver\n"));
16395 if (ent == (bfd_vma) -1)
16396 goto got_print_fail;
16397
16398 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16399 This entry will be used by some runtime loaders, to store the
16400 module pointer. Otherwise this is an ordinary local entry.
16401 PR 21344: Check for the entry being fully available before
16402 fetching it. */
16403 if (data
16404 && data + ent - pltgot + addr_size <= data_end
16405 && (byte_get (data + ent - pltgot, addr_size)
16406 >> (addr_size * 8 - 1)) != 0)
16407 {
16408 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16409 printf (_(" Module pointer (GNU extension)\n"));
16410 if (ent == (bfd_vma) -1)
16411 goto got_print_fail;
16412 }
16413 printf ("\n");
16414
16415 if (data != NULL && ent < local_end)
16416 {
16417 printf (_(" Local entries:\n"));
16418 printf (" %*s %10s %*s\n",
16419 addr_size * 2, _("Address"), _("Access"),
16420 addr_size * 2, _("Initial"));
16421 while (ent < local_end)
16422 {
16423 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16424 printf ("\n");
16425 if (ent == (bfd_vma) -1)
16426 goto got_print_fail;
16427 }
16428 printf ("\n");
16429 }
16430
16431 if (data != NULL && gotsym < symtabno)
16432 {
16433 int sym_width;
16434
16435 printf (_(" Global entries:\n"));
16436 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16437 addr_size * 2, _("Address"),
16438 _("Access"),
16439 addr_size * 2, _("Initial"),
16440 addr_size * 2, _("Sym.Val."),
16441 _("Type"),
16442 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16443 _("Ndx"), _("Name"));
16444
16445 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16446
16447 for (i = gotsym; i < symtabno; i++)
16448 {
16449 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16450 printf (" ");
16451
16452 if (dynamic_symbols == NULL)
16453 printf (_("<no dynamic symbols>"));
16454 else if (i < num_dynamic_syms)
16455 {
16456 Elf_Internal_Sym * psym = dynamic_symbols + i;
16457
16458 print_vma (psym->st_value, LONG_HEX);
16459 printf (" %-7s %3s ",
16460 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16461 get_symbol_index_type (filedata, psym->st_shndx));
16462
16463 if (VALID_DYNAMIC_NAME (psym->st_name))
16464 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16465 else
16466 printf (_("<corrupt: %14ld>"), psym->st_name);
16467 }
16468 else
16469 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16470 (unsigned long) i);
16471
16472 printf ("\n");
16473 if (ent == (bfd_vma) -1)
16474 break;
16475 }
16476 printf ("\n");
16477 }
16478
16479 got_print_fail:
16480 if (data)
16481 free (data);
16482 }
16483
16484 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16485 {
16486 bfd_vma ent, end;
16487 size_t offset, rel_offset;
16488 unsigned long count, i;
16489 unsigned char * data;
16490 int addr_size, sym_width;
16491 Elf_Internal_Rela * rels;
16492
16493 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16494 if (pltrel == DT_RELA)
16495 {
16496 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16497 return FALSE;
16498 }
16499 else
16500 {
16501 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16502 return FALSE;
16503 }
16504
16505 ent = mips_pltgot;
16506 addr_size = (is_32bit_elf ? 4 : 8);
16507 end = mips_pltgot + (2 + count) * addr_size;
16508
16509 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16510 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16511 1, _("Procedure Linkage Table data"));
16512 if (data == NULL)
16513 return FALSE;
16514
16515 printf ("\nPLT GOT:\n\n");
16516 printf (_(" Reserved entries:\n"));
16517 printf (_(" %*s %*s Purpose\n"),
16518 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16519 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16520 printf (_(" PLT lazy resolver\n"));
16521 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16522 printf (_(" Module pointer\n"));
16523 printf ("\n");
16524
16525 printf (_(" Entries:\n"));
16526 printf (" %*s %*s %*s %-7s %3s %s\n",
16527 addr_size * 2, _("Address"),
16528 addr_size * 2, _("Initial"),
16529 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16530 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16531 for (i = 0; i < count; i++)
16532 {
16533 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16534
16535 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16536 printf (" ");
16537
16538 if (idx >= num_dynamic_syms)
16539 printf (_("<corrupt symbol index: %lu>"), idx);
16540 else
16541 {
16542 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16543
16544 print_vma (psym->st_value, LONG_HEX);
16545 printf (" %-7s %3s ",
16546 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16547 get_symbol_index_type (filedata, psym->st_shndx));
16548 if (VALID_DYNAMIC_NAME (psym->st_name))
16549 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16550 else
16551 printf (_("<corrupt: %14ld>"), psym->st_name);
16552 }
16553 printf ("\n");
16554 }
16555 printf ("\n");
16556
16557 if (data)
16558 free (data);
16559 free (rels);
16560 }
16561
16562 return res;
16563}
16564
16565static bfd_boolean
16566process_nds32_specific (Filedata * filedata)
16567{
16568 Elf_Internal_Shdr *sect = NULL;
16569
16570 sect = find_section (filedata, ".nds32_e_flags");
16571 if (sect != NULL)
16572 {
16573 unsigned int *flag;
16574
16575 printf ("\nNDS32 elf flags section:\n");
16576 flag = get_data (NULL, filedata, sect->sh_offset, 1,
16577 sect->sh_size, _("NDS32 elf flags section"));
16578
16579 if (! flag)
16580 return FALSE;
16581
16582 switch ((*flag) & 0x3)
16583 {
16584 case 0:
16585 printf ("(VEC_SIZE):\tNo entry.\n");
16586 break;
16587 case 1:
16588 printf ("(VEC_SIZE):\t4 bytes\n");
16589 break;
16590 case 2:
16591 printf ("(VEC_SIZE):\t16 bytes\n");
16592 break;
16593 case 3:
16594 printf ("(VEC_SIZE):\treserved\n");
16595 break;
16596 }
16597 }
16598
16599 return TRUE;
16600}
16601
16602static bfd_boolean
16603process_gnu_liblist (Filedata * filedata)
16604{
16605 Elf_Internal_Shdr * section;
16606 Elf_Internal_Shdr * string_sec;
16607 Elf32_External_Lib * elib;
16608 char * strtab;
16609 size_t strtab_size;
16610 size_t cnt;
16611 unsigned long num_liblist;
16612 unsigned i;
16613 bfd_boolean res = TRUE;
16614
16615 if (! do_arch)
16616 return TRUE;
16617
16618 for (i = 0, section = filedata->section_headers;
16619 i < filedata->file_header.e_shnum;
16620 i++, section++)
16621 {
16622 switch (section->sh_type)
16623 {
16624 case SHT_GNU_LIBLIST:
16625 if (section->sh_link >= filedata->file_header.e_shnum)
16626 break;
16627
16628 elib = (Elf32_External_Lib *)
16629 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16630 _("liblist section data"));
16631
16632 if (elib == NULL)
16633 {
16634 res = FALSE;
16635 break;
16636 }
16637
16638 string_sec = filedata->section_headers + section->sh_link;
16639 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16640 string_sec->sh_size,
16641 _("liblist string table"));
16642 if (strtab == NULL
16643 || section->sh_entsize != sizeof (Elf32_External_Lib))
16644 {
16645 free (elib);
16646 free (strtab);
16647 res = FALSE;
16648 break;
16649 }
16650 strtab_size = string_sec->sh_size;
16651
16652 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16653 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16654 "\nLibrary list section '%s' contains %lu entries:\n",
16655 num_liblist),
16656 printable_section_name (filedata, section),
16657 num_liblist);
16658
16659 puts (_(" Library Time Stamp Checksum Version Flags"));
16660
16661 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16662 ++cnt)
16663 {
16664 Elf32_Lib liblist;
16665 time_t atime;
16666 char timebuf[128];
16667 struct tm * tmp;
16668
16669 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16670 atime = BYTE_GET (elib[cnt].l_time_stamp);
16671 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16672 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16673 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16674
16675 tmp = gmtime (&atime);
16676 snprintf (timebuf, sizeof (timebuf),
16677 "%04u-%02u-%02uT%02u:%02u:%02u",
16678 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16679 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16680
16681 printf ("%3lu: ", (unsigned long) cnt);
16682 if (do_wide)
16683 printf ("%-20s", liblist.l_name < strtab_size
16684 ? strtab + liblist.l_name : _("<corrupt>"));
16685 else
16686 printf ("%-20.20s", liblist.l_name < strtab_size
16687 ? strtab + liblist.l_name : _("<corrupt>"));
16688 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16689 liblist.l_version, liblist.l_flags);
16690 }
16691
16692 free (elib);
16693 free (strtab);
16694 }
16695 }
16696
16697 return res;
16698}
16699
16700static const char *
16701get_note_type (Filedata * filedata, unsigned e_type)
16702{
16703 static char buff[64];
16704
16705 if (filedata->file_header.e_type == ET_CORE)
16706 switch (e_type)
16707 {
16708 case NT_AUXV:
16709 return _("NT_AUXV (auxiliary vector)");
16710 case NT_PRSTATUS:
16711 return _("NT_PRSTATUS (prstatus structure)");
16712 case NT_FPREGSET:
16713 return _("NT_FPREGSET (floating point registers)");
16714 case NT_PRPSINFO:
16715 return _("NT_PRPSINFO (prpsinfo structure)");
16716 case NT_TASKSTRUCT:
16717 return _("NT_TASKSTRUCT (task structure)");
16718 case NT_PRXFPREG:
16719 return _("NT_PRXFPREG (user_xfpregs structure)");
16720 case NT_PPC_VMX:
16721 return _("NT_PPC_VMX (ppc Altivec registers)");
16722 case NT_PPC_VSX:
16723 return _("NT_PPC_VSX (ppc VSX registers)");
16724 case NT_PPC_TAR:
16725 return _("NT_PPC_TAR (ppc TAR register)");
16726 case NT_PPC_PPR:
16727 return _("NT_PPC_PPR (ppc PPR register)");
16728 case NT_PPC_DSCR:
16729 return _("NT_PPC_DSCR (ppc DSCR register)");
16730 case NT_PPC_EBB:
16731 return _("NT_PPC_EBB (ppc EBB registers)");
16732 case NT_PPC_PMU:
16733 return _("NT_PPC_PMU (ppc PMU registers)");
16734 case NT_PPC_TM_CGPR:
16735 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16736 case NT_PPC_TM_CFPR:
16737 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16738 case NT_PPC_TM_CVMX:
16739 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16740 case NT_PPC_TM_CVSX:
16741 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16742 case NT_PPC_TM_SPR:
16743 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16744 case NT_PPC_TM_CTAR:
16745 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16746 case NT_PPC_TM_CPPR:
16747 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16748 case NT_PPC_TM_CDSCR:
16749 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16750 case NT_386_TLS:
16751 return _("NT_386_TLS (x86 TLS information)");
16752 case NT_386_IOPERM:
16753 return _("NT_386_IOPERM (x86 I/O permissions)");
16754 case NT_X86_XSTATE:
16755 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16756 case NT_S390_HIGH_GPRS:
16757 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16758 case NT_S390_TIMER:
16759 return _("NT_S390_TIMER (s390 timer register)");
16760 case NT_S390_TODCMP:
16761 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16762 case NT_S390_TODPREG:
16763 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16764 case NT_S390_CTRS:
16765 return _("NT_S390_CTRS (s390 control registers)");
16766 case NT_S390_PREFIX:
16767 return _("NT_S390_PREFIX (s390 prefix register)");
16768 case NT_S390_LAST_BREAK:
16769 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16770 case NT_S390_SYSTEM_CALL:
16771 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16772 case NT_S390_TDB:
16773 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16774 case NT_S390_VXRS_LOW:
16775 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16776 case NT_S390_VXRS_HIGH:
16777 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16778 case NT_S390_GS_CB:
16779 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16780 case NT_S390_GS_BC:
16781 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16782 case NT_ARM_VFP:
16783 return _("NT_ARM_VFP (arm VFP registers)");
16784 case NT_ARM_TLS:
16785 return _("NT_ARM_TLS (AArch TLS registers)");
16786 case NT_ARM_HW_BREAK:
16787 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16788 case NT_ARM_HW_WATCH:
16789 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16790 case NT_PSTATUS:
16791 return _("NT_PSTATUS (pstatus structure)");
16792 case NT_FPREGS:
16793 return _("NT_FPREGS (floating point registers)");
16794 case NT_PSINFO:
16795 return _("NT_PSINFO (psinfo structure)");
16796 case NT_LWPSTATUS:
16797 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16798 case NT_LWPSINFO:
16799 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16800 case NT_WIN32PSTATUS:
16801 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16802 case NT_SIGINFO:
16803 return _("NT_SIGINFO (siginfo_t data)");
16804 case NT_FILE:
16805 return _("NT_FILE (mapped files)");
16806 default:
16807 break;
16808 }
16809 else
16810 switch (e_type)
16811 {
16812 case NT_VERSION:
16813 return _("NT_VERSION (version)");
16814 case NT_ARCH:
16815 return _("NT_ARCH (architecture)");
16816 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16817 return _("OPEN");
16818 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16819 return _("func");
16820 default:
16821 break;
16822 }
16823
16824 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16825 return buff;
16826}
16827
16828static bfd_boolean
16829print_core_note (Elf_Internal_Note *pnote)
16830{
16831 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16832 bfd_vma count, page_size;
16833 unsigned char *descdata, *filenames, *descend;
16834
16835 if (pnote->type != NT_FILE)
16836 {
16837 if (do_wide)
16838 printf ("\n");
16839 return TRUE;
16840 }
16841
16842#ifndef BFD64
16843 if (!is_32bit_elf)
16844 {
16845 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16846 /* Still "successful". */
16847 return TRUE;
16848 }
16849#endif
16850
16851 if (pnote->descsz < 2 * addr_size)
16852 {
16853 error (_(" Malformed note - too short for header\n"));
16854 return FALSE;
16855 }
16856
16857 descdata = (unsigned char *) pnote->descdata;
16858 descend = descdata + pnote->descsz;
16859
16860 if (descdata[pnote->descsz - 1] != '\0')
16861 {
16862 error (_(" Malformed note - does not end with \\0\n"));
16863 return FALSE;
16864 }
16865
16866 count = byte_get (descdata, addr_size);
16867 descdata += addr_size;
16868
16869 page_size = byte_get (descdata, addr_size);
16870 descdata += addr_size;
16871
16872 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16873 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16874 {
16875 error (_(" Malformed note - too short for supplied file count\n"));
16876 return FALSE;
16877 }
16878
16879 printf (_(" Page size: "));
16880 print_vma (page_size, DEC);
16881 printf ("\n");
16882
16883 printf (_(" %*s%*s%*s\n"),
16884 (int) (2 + 2 * addr_size), _("Start"),
16885 (int) (4 + 2 * addr_size), _("End"),
16886 (int) (4 + 2 * addr_size), _("Page Offset"));
16887 filenames = descdata + count * 3 * addr_size;
16888 while (count-- > 0)
16889 {
16890 bfd_vma start, end, file_ofs;
16891
16892 if (filenames == descend)
16893 {
16894 error (_(" Malformed note - filenames end too early\n"));
16895 return FALSE;
16896 }
16897
16898 start = byte_get (descdata, addr_size);
16899 descdata += addr_size;
16900 end = byte_get (descdata, addr_size);
16901 descdata += addr_size;
16902 file_ofs = byte_get (descdata, addr_size);
16903 descdata += addr_size;
16904
16905 printf (" ");
16906 print_vma (start, FULL_HEX);
16907 printf (" ");
16908 print_vma (end, FULL_HEX);
16909 printf (" ");
16910 print_vma (file_ofs, FULL_HEX);
16911 printf ("\n %s\n", filenames);
16912
16913 filenames += 1 + strlen ((char *) filenames);
16914 }
16915
16916 return TRUE;
16917}
16918
16919static const char *
16920get_gnu_elf_note_type (unsigned e_type)
16921{
16922 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16923 switch (e_type)
16924 {
16925 case NT_GNU_ABI_TAG:
16926 return _("NT_GNU_ABI_TAG (ABI version tag)");
16927 case NT_GNU_HWCAP:
16928 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16929 case NT_GNU_BUILD_ID:
16930 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16931 case NT_GNU_GOLD_VERSION:
16932 return _("NT_GNU_GOLD_VERSION (gold version)");
16933 case NT_GNU_PROPERTY_TYPE_0:
16934 return _("NT_GNU_PROPERTY_TYPE_0");
16935 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16936 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16937 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16938 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16939 default:
16940 {
16941 static char buff[64];
16942
16943 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16944 return buff;
16945 }
16946 }
16947}
16948
16949static void
16950decode_x86_isa (unsigned int bitmask)
16951{
16952 while (bitmask)
16953 {
16954 unsigned int bit = bitmask & (- bitmask);
16955
16956 bitmask &= ~ bit;
16957 switch (bit)
16958 {
16959 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16960 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16961 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16962 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16963 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16964 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16965 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16966 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16967 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16968 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16969 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16970 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16971 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16972 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16973 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16974 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16975 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16976 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16977 default: printf (_("<unknown: %x>"), bit); break;
16978 }
16979 if (bitmask)
16980 printf (", ");
16981 }
16982}
16983
16984static void
16985decode_x86_feature (unsigned int type, unsigned int bitmask)
16986{
16987 while (bitmask)
16988 {
16989 unsigned int bit = bitmask & (- bitmask);
16990
16991 bitmask &= ~ bit;
16992 switch (bit)
16993 {
16994 case GNU_PROPERTY_X86_FEATURE_1_IBT:
16995 switch (type)
16996 {
16997 case GNU_PROPERTY_X86_FEATURE_1_AND:
16998 printf ("IBT");
16999 break;
17000 default:
17001 /* This should never happen. */
17002 abort ();
17003 }
17004 break;
17005 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17006 switch (type)
17007 {
17008 case GNU_PROPERTY_X86_FEATURE_1_AND:
17009 printf ("SHSTK");
17010 break;
17011 default:
17012 /* This should never happen. */
17013 abort ();
17014 }
17015 break;
17016 default:
17017 printf (_("<unknown: %x>"), bit);
17018 break;
17019 }
17020 if (bitmask)
17021 printf (", ");
17022 }
17023}
17024
17025static void
17026print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17027{
17028 unsigned char * ptr = (unsigned char *) pnote->descdata;
17029 unsigned char * ptr_end = ptr + pnote->descsz;
17030 unsigned int size = is_32bit_elf ? 4 : 8;
17031
17032 printf (_(" Properties: "));
17033
17034 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17035 {
17036 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17037 return;
17038 }
17039
17040 while (ptr < ptr_end)
17041 {
17042 unsigned int j;
17043 unsigned int type;
17044 unsigned int datasz;
17045
17046 if ((size_t) (ptr_end - ptr) < 8)
17047 {
17048 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17049 break;
17050 }
17051
17052 type = byte_get (ptr, 4);
17053 datasz = byte_get (ptr + 4, 4);
17054
17055 ptr += 8;
17056
17057 if (datasz > (size_t) (ptr_end - ptr))
17058 {
17059 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17060 type, datasz);
17061 break;
17062 }
17063
17064 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17065 {
17066 if (filedata->file_header.e_machine == EM_X86_64
17067 || filedata->file_header.e_machine == EM_IAMCU
17068 || filedata->file_header.e_machine == EM_386)
17069 {
17070 unsigned int bitmask;
17071
17072 if (datasz == 4)
17073 {
17074 bitmask = byte_get (ptr, 4);
17075 if (filedata->file_header.e_type == ET_EXEC
17076 || filedata->file_header.e_type == ET_DYN)
17077 {
17078 if ((bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17079 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17080 else
17081 printf ("Invalid ");
17082 }
17083 }
17084 else
17085 bitmask = 0;
17086
17087 switch (type)
17088 {
17089 case GNU_PROPERTY_X86_ISA_1_USED:
17090 if (datasz != 4)
17091 printf (_("x86 ISA used: <corrupt length: %#x> "),
17092 datasz);
17093 else
17094 {
17095 printf ("x86 ISA used: ");
17096 decode_x86_isa (bitmask);
17097 }
17098 goto next;
17099
17100 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17101 if (datasz != 4)
17102 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17103 datasz);
17104 else
17105 {
17106 printf ("x86 ISA needed: ");
17107 decode_x86_isa (bitmask);
17108 }
17109 goto next;
17110
17111 case GNU_PROPERTY_X86_FEATURE_1_AND:
17112 if (datasz != 4)
17113 printf (_("x86 feature: <corrupt length: %#x> "),
17114 datasz);
17115 else
17116 {
17117 printf ("x86 feature: ");
17118 decode_x86_feature (type, bitmask);
17119 }
17120 goto next;
17121
17122 default:
17123 break;
17124 }
17125 }
17126 }
17127 else
17128 {
17129 switch (type)
17130 {
17131 case GNU_PROPERTY_STACK_SIZE:
17132 printf (_("stack size: "));
17133 if (datasz != size)
17134 printf (_("<corrupt length: %#x> "), datasz);
17135 else
17136 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17137 goto next;
17138
17139 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17140 printf ("no copy on protected ");
17141 if (datasz)
17142 printf (_("<corrupt length: %#x> "), datasz);
17143 goto next;
17144
17145 default:
17146 break;
17147 }
17148 }
17149
17150 if (type < GNU_PROPERTY_LOPROC)
17151 printf (_("<unknown type %#x data: "), type);
17152 else if (type < GNU_PROPERTY_LOUSER)
17153 printf (_("<procesor-specific type %#x data: "), type);
17154 else
17155 printf (_("<application-specific type %#x data: "), type);
17156 for (j = 0; j < datasz; ++j)
17157 printf ("%02x ", ptr[j] & 0xff);
17158 printf (">");
17159
17160next:
17161 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17162 if (ptr == ptr_end)
17163 break;
17164
17165 if (do_wide)
17166 printf (", ");
17167 else
17168 printf ("\n\t");
17169 }
17170
17171 printf ("\n");
17172}
17173
17174static bfd_boolean
17175print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17176{
17177 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17178 switch (pnote->type)
17179 {
17180 case NT_GNU_BUILD_ID:
17181 {
17182 unsigned long i;
17183
17184 printf (_(" Build ID: "));
17185 for (i = 0; i < pnote->descsz; ++i)
17186 printf ("%02x", pnote->descdata[i] & 0xff);
17187 printf ("\n");
17188 }
17189 break;
17190
17191 case NT_GNU_ABI_TAG:
17192 {
17193 unsigned long os, major, minor, subminor;
17194 const char *osname;
17195
17196 /* PR 17531: file: 030-599401-0.004. */
17197 if (pnote->descsz < 16)
17198 {
17199 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17200 break;
17201 }
17202
17203 os = byte_get ((unsigned char *) pnote->descdata, 4);
17204 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17205 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17206 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17207
17208 switch (os)
17209 {
17210 case GNU_ABI_TAG_LINUX:
17211 osname = "Linux";
17212 break;
17213 case GNU_ABI_TAG_HURD:
17214 osname = "Hurd";
17215 break;
17216 case GNU_ABI_TAG_SOLARIS:
17217 osname = "Solaris";
17218 break;
17219 case GNU_ABI_TAG_FREEBSD:
17220 osname = "FreeBSD";
17221 break;
17222 case GNU_ABI_TAG_NETBSD:
17223 osname = "NetBSD";
17224 break;
17225 case GNU_ABI_TAG_SYLLABLE:
17226 osname = "Syllable";
17227 break;
17228 case GNU_ABI_TAG_NACL:
17229 osname = "NaCl";
17230 break;
17231 default:
17232 osname = "Unknown";
17233 break;
17234 }
17235
17236 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17237 major, minor, subminor);
17238 }
17239 break;
17240
17241 case NT_GNU_GOLD_VERSION:
17242 {
17243 unsigned long i;
17244
17245 printf (_(" Version: "));
17246 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17247 printf ("%c", pnote->descdata[i]);
17248 printf ("\n");
17249 }
17250 break;
17251
17252 case NT_GNU_HWCAP:
17253 {
17254 unsigned long num_entries, mask;
17255
17256 /* Hardware capabilities information. Word 0 is the number of entries.
17257 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17258 is a series of entries, where each entry is a single byte followed
17259 by a nul terminated string. The byte gives the bit number to test
17260 if enabled in the bitmask. */
17261 printf (_(" Hardware Capabilities: "));
17262 if (pnote->descsz < 8)
17263 {
17264 error (_("<corrupt GNU_HWCAP>\n"));
17265 return FALSE;
17266 }
17267 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17268 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17269 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17270 /* FIXME: Add code to display the entries... */
17271 }
17272 break;
17273
17274 case NT_GNU_PROPERTY_TYPE_0:
17275 print_gnu_property_note (filedata, pnote);
17276 break;
17277
17278 default:
17279 /* Handle unrecognised types. An error message should have already been
17280 created by get_gnu_elf_note_type(), so all that we need to do is to
17281 display the data. */
17282 {
17283 unsigned long i;
17284
17285 printf (_(" Description data: "));
17286 for (i = 0; i < pnote->descsz; ++i)
17287 printf ("%02x ", pnote->descdata[i] & 0xff);
17288 printf ("\n");
17289 }
17290 break;
17291 }
17292
17293 return TRUE;
17294}
17295
17296static const char *
17297get_v850_elf_note_type (enum v850_notes n_type)
17298{
17299 static char buff[64];
17300
17301 switch (n_type)
17302 {
17303 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17304 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17305 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17306 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17307 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17308 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17309 default:
17310 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17311 return buff;
17312 }
17313}
17314
17315static bfd_boolean
17316print_v850_note (Elf_Internal_Note * pnote)
17317{
17318 unsigned int val;
17319
17320 if (pnote->descsz != 4)
17321 return FALSE;
17322
17323 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17324
17325 if (val == 0)
17326 {
17327 printf (_("not set\n"));
17328 return TRUE;
17329 }
17330
17331 switch (pnote->type)
17332 {
17333 case V850_NOTE_ALIGNMENT:
17334 switch (val)
17335 {
17336 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17337 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17338 }
17339 break;
17340
17341 case V850_NOTE_DATA_SIZE:
17342 switch (val)
17343 {
17344 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17345 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17346 }
17347 break;
17348
17349 case V850_NOTE_FPU_INFO:
17350 switch (val)
17351 {
17352 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17353 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17354 }
17355 break;
17356
17357 case V850_NOTE_MMU_INFO:
17358 case V850_NOTE_CACHE_INFO:
17359 case V850_NOTE_SIMD_INFO:
17360 if (val == EF_RH850_SIMD)
17361 {
17362 printf (_("yes\n"));
17363 return TRUE;
17364 }
17365 break;
17366
17367 default:
17368 /* An 'unknown note type' message will already have been displayed. */
17369 break;
17370 }
17371
17372 printf (_("unknown value: %x\n"), val);
17373 return FALSE;
17374}
17375
17376static bfd_boolean
17377process_netbsd_elf_note (Elf_Internal_Note * pnote)
17378{
17379 unsigned int version;
17380
17381 switch (pnote->type)
17382 {
17383 case NT_NETBSD_IDENT:
17384 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17385 if ((version / 10000) % 100)
17386 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17387 version, version / 100000000, (version / 1000000) % 100,
17388 (version / 10000) % 100 > 26 ? "Z" : "",
17389 'A' + (version / 10000) % 26);
17390 else
17391 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17392 version, version / 100000000, (version / 1000000) % 100,
17393 (version / 100) % 100);
17394 return TRUE;
17395
17396 case NT_NETBSD_MARCH:
17397 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17398 pnote->descdata);
17399 return TRUE;
17400
17401 default:
17402 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17403 pnote->type);
17404 return FALSE;
17405 }
17406}
17407
17408static const char *
17409get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17410{
17411 switch (e_type)
17412 {
17413 case NT_FREEBSD_THRMISC:
17414 return _("NT_THRMISC (thrmisc structure)");
17415 case NT_FREEBSD_PROCSTAT_PROC:
17416 return _("NT_PROCSTAT_PROC (proc data)");
17417 case NT_FREEBSD_PROCSTAT_FILES:
17418 return _("NT_PROCSTAT_FILES (files data)");
17419 case NT_FREEBSD_PROCSTAT_VMMAP:
17420 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17421 case NT_FREEBSD_PROCSTAT_GROUPS:
17422 return _("NT_PROCSTAT_GROUPS (groups data)");
17423 case NT_FREEBSD_PROCSTAT_UMASK:
17424 return _("NT_PROCSTAT_UMASK (umask data)");
17425 case NT_FREEBSD_PROCSTAT_RLIMIT:
17426 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17427 case NT_FREEBSD_PROCSTAT_OSREL:
17428 return _("NT_PROCSTAT_OSREL (osreldate data)");
17429 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17430 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17431 case NT_FREEBSD_PROCSTAT_AUXV:
17432 return _("NT_PROCSTAT_AUXV (auxv data)");
17433 case NT_FREEBSD_PTLWPINFO:
17434 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17435 }
17436 return get_note_type (filedata, e_type);
17437}
17438
17439static const char *
17440get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17441{
17442 static char buff[64];
17443
17444 if (e_type == NT_NETBSDCORE_PROCINFO)
17445 return _("NetBSD procinfo structure");
17446
17447 /* As of Jan 2002 there are no other machine-independent notes
17448 defined for NetBSD core files. If the note type is less
17449 than the start of the machine-dependent note types, we don't
17450 understand it. */
17451
17452 if (e_type < NT_NETBSDCORE_FIRSTMACH)
17453 {
17454 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17455 return buff;
17456 }
17457
17458 switch (filedata->file_header.e_machine)
17459 {
17460 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17461 and PT_GETFPREGS == mach+2. */
17462
17463 case EM_OLD_ALPHA:
17464 case EM_ALPHA:
17465 case EM_SPARC:
17466 case EM_SPARC32PLUS:
17467 case EM_SPARCV9:
17468 switch (e_type)
17469 {
17470 case NT_NETBSDCORE_FIRSTMACH + 0:
17471 return _("PT_GETREGS (reg structure)");
17472 case NT_NETBSDCORE_FIRSTMACH + 2:
17473 return _("PT_GETFPREGS (fpreg structure)");
17474 default:
17475 break;
17476 }
17477 break;
17478
17479 /* On all other arch's, PT_GETREGS == mach+1 and
17480 PT_GETFPREGS == mach+3. */
17481 default:
17482 switch (e_type)
17483 {
17484 case NT_NETBSDCORE_FIRSTMACH + 1:
17485 return _("PT_GETREGS (reg structure)");
17486 case NT_NETBSDCORE_FIRSTMACH + 3:
17487 return _("PT_GETFPREGS (fpreg structure)");
17488 default:
17489 break;
17490 }
17491 }
17492
17493 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17494 e_type - NT_NETBSDCORE_FIRSTMACH);
17495 return buff;
17496}
17497
17498static const char *
17499get_stapsdt_note_type (unsigned e_type)
17500{
17501 static char buff[64];
17502
17503 switch (e_type)
17504 {
17505 case NT_STAPSDT:
17506 return _("NT_STAPSDT (SystemTap probe descriptors)");
17507
17508 default:
17509 break;
17510 }
17511
17512 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17513 return buff;
17514}
17515
17516static bfd_boolean
17517print_stapsdt_note (Elf_Internal_Note *pnote)
17518{
17519 int addr_size = is_32bit_elf ? 4 : 8;
17520 char *data = pnote->descdata;
17521 char *data_end = pnote->descdata + pnote->descsz;
17522 bfd_vma pc, base_addr, semaphore;
17523 char *provider, *probe, *arg_fmt;
17524
17525 pc = byte_get ((unsigned char *) data, addr_size);
17526 data += addr_size;
17527 base_addr = byte_get ((unsigned char *) data, addr_size);
17528 data += addr_size;
17529 semaphore = byte_get ((unsigned char *) data, addr_size);
17530 data += addr_size;
17531
17532 provider = data;
17533 data += strlen (data) + 1;
17534 probe = data;
17535 data += strlen (data) + 1;
17536 arg_fmt = data;
17537 data += strlen (data) + 1;
17538
17539 printf (_(" Provider: %s\n"), provider);
17540 printf (_(" Name: %s\n"), probe);
17541 printf (_(" Location: "));
17542 print_vma (pc, FULL_HEX);
17543 printf (_(", Base: "));
17544 print_vma (base_addr, FULL_HEX);
17545 printf (_(", Semaphore: "));
17546 print_vma (semaphore, FULL_HEX);
17547 printf ("\n");
17548 printf (_(" Arguments: %s\n"), arg_fmt);
17549
17550 return data == data_end;
17551}
17552
17553static const char *
17554get_ia64_vms_note_type (unsigned e_type)
17555{
17556 static char buff[64];
17557
17558 switch (e_type)
17559 {
17560 case NT_VMS_MHD:
17561 return _("NT_VMS_MHD (module header)");
17562 case NT_VMS_LNM:
17563 return _("NT_VMS_LNM (language name)");
17564 case NT_VMS_SRC:
17565 return _("NT_VMS_SRC (source files)");
17566 case NT_VMS_TITLE:
17567 return "NT_VMS_TITLE";
17568 case NT_VMS_EIDC:
17569 return _("NT_VMS_EIDC (consistency check)");
17570 case NT_VMS_FPMODE:
17571 return _("NT_VMS_FPMODE (FP mode)");
17572 case NT_VMS_LINKTIME:
17573 return "NT_VMS_LINKTIME";
17574 case NT_VMS_IMGNAM:
17575 return _("NT_VMS_IMGNAM (image name)");
17576 case NT_VMS_IMGID:
17577 return _("NT_VMS_IMGID (image id)");
17578 case NT_VMS_LINKID:
17579 return _("NT_VMS_LINKID (link id)");
17580 case NT_VMS_IMGBID:
17581 return _("NT_VMS_IMGBID (build id)");
17582 case NT_VMS_GSTNAM:
17583 return _("NT_VMS_GSTNAM (sym table name)");
17584 case NT_VMS_ORIG_DYN:
17585 return "NT_VMS_ORIG_DYN";
17586 case NT_VMS_PATCHTIME:
17587 return "NT_VMS_PATCHTIME";
17588 default:
17589 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17590 return buff;
17591 }
17592}
17593
17594static bfd_boolean
17595print_ia64_vms_note (Elf_Internal_Note * pnote)
17596{
17597 switch (pnote->type)
17598 {
17599 case NT_VMS_MHD:
17600 if (pnote->descsz > 36)
17601 {
17602 size_t l = strlen (pnote->descdata + 34);
17603 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17604 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17605 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17606 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17607 }
17608 else
17609 printf (_(" Invalid size\n"));
17610 break;
17611 case NT_VMS_LNM:
17612 printf (_(" Language: %s\n"), pnote->descdata);
17613 break;
17614#ifdef BFD64
17615 case NT_VMS_FPMODE:
17616 printf (_(" Floating Point mode: "));
17617 printf ("0x%016" BFD_VMA_FMT "x\n",
17618 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17619 break;
17620 case NT_VMS_LINKTIME:
17621 printf (_(" Link time: "));
17622 print_vms_time
17623 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17624 printf ("\n");
17625 break;
17626 case NT_VMS_PATCHTIME:
17627 printf (_(" Patch time: "));
17628 print_vms_time
17629 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17630 printf ("\n");
17631 break;
17632 case NT_VMS_ORIG_DYN:
17633 printf (_(" Major id: %u, minor id: %u\n"),
17634 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17635 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17636 printf (_(" Last modified : "));
17637 print_vms_time
17638 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17639 printf (_("\n Link flags : "));
17640 printf ("0x%016" BFD_VMA_FMT "x\n",
17641 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17642 printf (_(" Header flags: 0x%08x\n"),
17643 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17644 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17645 break;
17646#endif
17647 case NT_VMS_IMGNAM:
17648 printf (_(" Image name: %s\n"), pnote->descdata);
17649 break;
17650 case NT_VMS_GSTNAM:
17651 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17652 break;
17653 case NT_VMS_IMGID:
17654 printf (_(" Image id: %s\n"), pnote->descdata);
17655 break;
17656 case NT_VMS_LINKID:
17657 printf (_(" Linker id: %s\n"), pnote->descdata);
17658 break;
17659 default:
17660 return FALSE;
17661 }
17662 return TRUE;
17663}
17664
17665/* Find the symbol associated with a build attribute that is attached
17666 to address OFFSET. If PNAME is non-NULL then store the name of
17667 the symbol (if found) in the provided pointer, Returns NULL if a
17668 symbol could not be found. */
17669
17670static Elf_Internal_Sym *
17671get_symbol_for_build_attribute (Filedata * filedata,
17672 unsigned long offset,
17673 bfd_boolean is_open_attr,
17674 const char ** pname)
17675{
17676 static Filedata * saved_filedata = NULL;
17677 static char * strtab;
17678 static unsigned long strtablen;
17679 static Elf_Internal_Sym * symtab;
17680 static unsigned long nsyms;
17681 Elf_Internal_Sym * saved_sym = NULL;
17682 Elf_Internal_Sym * sym;
17683
17684 if (filedata->section_headers != NULL
17685 && (saved_filedata == NULL || filedata != saved_filedata))
17686 {
17687 Elf_Internal_Shdr * symsec;
17688
17689 /* Load the symbol and string sections. */
17690 for (symsec = filedata->section_headers;
17691 symsec < filedata->section_headers + filedata->file_header.e_shnum;
17692 symsec ++)
17693 {
17694 if (symsec->sh_type == SHT_SYMTAB)
17695 {
17696 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17697
17698 if (symsec->sh_link < filedata->file_header.e_shnum)
17699 {
17700 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17701
17702 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17703 1, strtab_sec->sh_size,
17704 _("string table"));
17705 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17706 }
17707 }
17708 }
17709 saved_filedata = filedata;
17710 }
17711
17712 if (symtab == NULL || strtab == NULL)
17713 return NULL;
17714
17715 /* Find a symbol whose value matches offset. */
17716 for (sym = symtab; sym < symtab + nsyms; sym ++)
17717 if (sym->st_value == offset)
17718 {
17719 if (sym->st_name >= strtablen)
17720 /* Huh ? This should not happen. */
17721 continue;
17722
17723 if (strtab[sym->st_name] == 0)
17724 continue;
17725
17726 /* The AArch64 and ARM architectures define mapping symbols
17727 (eg $d, $x, $t) which we want to ignore. */
17728 if (strtab[sym->st_name] == '$'
17729 && strtab[sym->st_name + 1] != 0
17730 && strtab[sym->st_name + 2] == 0)
17731 continue;
17732
17733 if (is_open_attr)
17734 {
17735 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17736 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17737 FUNC symbols entirely. */
17738 switch (ELF_ST_TYPE (sym->st_info))
17739 {
17740 case STT_OBJECT:
17741 case STT_FILE:
17742 saved_sym = sym;
17743 if (sym->st_size)
17744 {
17745 /* If the symbol has a size associated
17746 with it then we can stop searching. */
17747 sym = symtab + nsyms;
17748 }
17749 continue;
17750
17751 case STT_FUNC:
17752 /* Ignore function symbols. */
17753 continue;
17754
17755 default:
17756 break;
17757 }
17758
17759 switch (ELF_ST_BIND (sym->st_info))
17760 {
17761 case STB_GLOBAL:
17762 if (saved_sym == NULL
17763 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17764 saved_sym = sym;
17765 break;
17766
17767 case STB_LOCAL:
17768 if (saved_sym == NULL)
17769 saved_sym = sym;
17770 break;
17771
17772 default:
17773 break;
17774 }
17775 }
17776 else
17777 {
17778 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17779 continue;
17780
17781 saved_sym = sym;
17782 break;
17783 }
17784 }
17785
17786 if (saved_sym && pname)
17787 * pname = strtab + saved_sym->st_name;
17788
17789 return saved_sym;
17790}
17791
17792/* Returns true iff addr1 and addr2 are in the same section. */
17793
17794static bfd_boolean
17795same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
17796{
17797 Elf_Internal_Shdr * a1;
17798 Elf_Internal_Shdr * a2;
17799
17800 a1 = find_section_by_address (filedata, addr1);
17801 a2 = find_section_by_address (filedata, addr2);
17802
17803 return a1 == a2 && a1 != NULL;
17804}
17805
17806static bfd_boolean
17807print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17808 Filedata * filedata)
17809{
17810 static unsigned long global_offset = 0;
17811 static unsigned long global_end = 0;
17812 static unsigned long func_offset = 0;
17813 static unsigned long func_end = 0;
17814
17815 Elf_Internal_Sym * sym;
17816 const char * name;
17817 unsigned long start;
17818 unsigned long end;
17819 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17820
17821 switch (pnote->descsz)
17822 {
17823 case 0:
17824 /* A zero-length description means that the range of
17825 the previous note of the same type should be used. */
17826 if (is_open_attr)
17827 {
17828 if (global_end > global_offset)
17829 printf (_(" Applies to region from %#lx to %#lx\n"),
17830 global_offset, global_end);
17831 else
17832 printf (_(" Applies to region from %#lx\n"), global_offset);
17833 }
17834 else
17835 {
17836 if (func_end > func_offset)
17837 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17838 else
17839 printf (_(" Applies to region from %#lx\n"), func_offset);
17840 }
17841 return TRUE;
17842
17843 case 4:
17844 start = byte_get ((unsigned char *) pnote->descdata, 4);
17845 end = 0;
17846 break;
17847
17848 case 8:
17849 if (is_32bit_elf)
17850 {
17851 /* FIXME: We should check that version 3+ notes are being used here... */
17852 start = byte_get ((unsigned char *) pnote->descdata, 4);
17853 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17854 }
17855 else
17856 {
17857 start = byte_get ((unsigned char *) pnote->descdata, 8);
17858 end = 0;
17859 }
17860 break;
17861
17862 case 16:
17863 start = byte_get ((unsigned char *) pnote->descdata, 8);
17864 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17865 break;
17866
17867 default:
17868 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
17869 printf (_(" <invalid descsz>"));
17870 return FALSE;
17871 }
17872
17873 name = NULL;
17874 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17875 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17876 in order to avoid them being confused with the start address of the
17877 first function in the file... */
17878 if (sym == NULL && is_open_attr)
17879 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17880 & name);
17881
17882 if (end == 0 && sym != NULL && sym->st_size > 0)
17883 end = start + sym->st_size;
17884
17885 if (is_open_attr)
17886 {
17887 /* FIXME: Need to properly allow for section alignment.
17888 16 is just the alignment used on x86_64. */
17889 if (global_end > 0
17890 && start > BFD_ALIGN (global_end, 16)
17891 /* Build notes are not guaranteed to be organised in order of
17892 increasing address, but we should find the all of the notes
17893 for one section in the same place. */
17894 && same_section (filedata, start, global_end))
17895 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17896 global_end + 1, start - 1);
17897
17898 printf (_(" Applies to region from %#lx"), start);
17899 global_offset = start;
17900
17901 if (end)
17902 {
17903 printf (_(" to %#lx"), end);
17904 global_end = end;
17905 }
17906 }
17907 else
17908 {
17909 printf (_(" Applies to region from %#lx"), start);
17910 func_offset = start;
17911
17912 if (end)
17913 {
17914 printf (_(" to %#lx"), end);
17915 func_end = end;
17916 }
17917 }
17918
17919 if (sym && name)
17920 printf (_(" (%s)"), name);
17921
17922 printf ("\n");
17923 return TRUE;
17924}
17925
17926static bfd_boolean
17927print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17928{
17929 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17930 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17931 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17932 char name_type;
17933 char name_attribute;
17934 const char * expected_types;
17935 const char * name = pnote->namedata;
17936 const char * text;
17937 signed int left;
17938
17939 if (name == NULL || pnote->namesz < 2)
17940 {
17941 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17942 print_symbol (-20, _(" <corrupt name>"));
17943 return FALSE;
17944 }
17945
17946 if (do_wide)
17947 left = 28;
17948 else
17949 left = 20;
17950
17951 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17952 if (name[0] == 'G' && name[1] == 'A')
17953 {
17954 if (pnote->namesz < 4)
17955 {
17956 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17957 print_symbol (-20, _(" <corrupt name>"));
17958 return FALSE;
17959 }
17960
17961 printf ("GA");
17962 name += 2;
17963 left -= 2;
17964 }
17965
17966 switch ((name_type = * name))
17967 {
17968 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17969 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17970 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17971 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17972 printf ("%c", * name);
17973 left --;
17974 break;
17975 default:
17976 error (_("unrecognised attribute type in name field: %d\n"), name_type);
17977 print_symbol (-20, _("<unknown name type>"));
17978 return FALSE;
17979 }
17980
17981 ++ name;
17982 text = NULL;
17983
17984 switch ((name_attribute = * name))
17985 {
17986 case GNU_BUILD_ATTRIBUTE_VERSION:
17987 text = _("<version>");
17988 expected_types = string_expected;
17989 ++ name;
17990 break;
17991 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17992 text = _("<stack prot>");
17993 expected_types = "!+*";
17994 ++ name;
17995 break;
17996 case GNU_BUILD_ATTRIBUTE_RELRO:
17997 text = _("<relro>");
17998 expected_types = bool_expected;
17999 ++ name;
18000 break;
18001 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18002 text = _("<stack size>");
18003 expected_types = number_expected;
18004 ++ name;
18005 break;
18006 case GNU_BUILD_ATTRIBUTE_TOOL:
18007 text = _("<tool>");
18008 expected_types = string_expected;
18009 ++ name;
18010 break;
18011 case GNU_BUILD_ATTRIBUTE_ABI:
18012 text = _("<ABI>");
18013 expected_types = "$*";
18014 ++ name;
18015 break;
18016 case GNU_BUILD_ATTRIBUTE_PIC:
18017 text = _("<PIC>");
18018 expected_types = number_expected;
18019 ++ name;
18020 break;
18021 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18022 text = _("<short enum>");
18023 expected_types = bool_expected;
18024 ++ name;
18025 break;
18026 default:
18027 if (ISPRINT (* name))
18028 {
18029 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18030
18031 if (len > left && ! do_wide)
18032 len = left;
18033 printf ("%.*s:", len, name);
18034 left -= len;
18035 name += len;
18036 }
18037 else
18038 {
18039 static char tmpbuf [128];
18040
18041 error (_("unrecognised byte in name field: %d\n"), * name);
18042 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18043 text = tmpbuf;
18044 name ++;
18045 }
18046 expected_types = "*$!+";
18047 break;
18048 }
18049
18050 if (text)
18051 left -= printf ("%s", text);
18052
18053 if (strchr (expected_types, name_type) == NULL)
18054 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18055
18056 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18057 {
18058 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18059 (unsigned long) pnote->namesz,
18060 (long) (name - pnote->namedata));
18061 return FALSE;
18062 }
18063
18064 if (left < 1 && ! do_wide)
18065 return TRUE;
18066
18067 switch (name_type)
18068 {
18069 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18070 {
18071 unsigned int bytes;
18072 unsigned long long val = 0;
18073 unsigned int shift = 0;
18074 char * decoded = NULL;
18075
18076 bytes = pnote->namesz - (name - pnote->namedata);
18077 if (bytes > 0)
18078 /* The -1 is because the name field is always 0 terminated, and we
18079 want to be able to ensure that the shift in the while loop below
18080 will not overflow. */
18081 -- bytes;
18082
18083 if (bytes > sizeof (val))
18084 {
18085 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18086 bytes);
18087 bytes = sizeof (val);
18088 }
18089 /* We do not bother to warn if bytes == 0 as this can
18090 happen with some early versions of the gcc plugin. */
18091
18092 while (bytes --)
18093 {
18094 unsigned long byte = (* name ++) & 0xff;
18095
18096 val |= byte << shift;
18097 shift += 8;
18098 }
18099
18100 switch (name_attribute)
18101 {
18102 case GNU_BUILD_ATTRIBUTE_PIC:
18103 switch (val)
18104 {
18105 case 0: decoded = "static"; break;
18106 case 1: decoded = "pic"; break;
18107 case 2: decoded = "PIC"; break;
18108 case 3: decoded = "pie"; break;
18109 case 4: decoded = "PIE"; break;
18110 default: break;
18111 }
18112 break;
18113 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18114 switch (val)
18115 {
18116 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18117 case 0: decoded = "off"; break;
18118 case 1: decoded = "on"; break;
18119 case 2: decoded = "all"; break;
18120 case 3: decoded = "strong"; break;
18121 case 4: decoded = "explicit"; break;
18122 default: break;
18123 }
18124 break;
18125 default:
18126 break;
18127 }
18128
18129 if (decoded != NULL)
18130 {
18131 print_symbol (-left, decoded);
18132 left = 0;
18133 }
18134 else if (val == 0)
18135 {
18136 printf ("0x0");
18137 left -= 3;
18138 }
18139 else
18140 {
18141 if (do_wide)
18142 left -= printf ("0x%llx", val);
18143 else
18144 left -= printf ("0x%-.*llx", left, val);
18145 }
18146 }
18147 break;
18148 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18149 left -= print_symbol (- left, name);
18150 break;
18151 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18152 left -= print_symbol (- left, "true");
18153 break;
18154 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18155 left -= print_symbol (- left, "false");
18156 break;
18157 }
18158
18159 if (do_wide && left > 0)
18160 printf ("%-*s", left, " ");
18161
18162 return TRUE;
18163}
18164
18165/* Note that by the ELF standard, the name field is already null byte
18166 terminated, and namesz includes the terminating null byte.
18167 I.E. the value of namesz for the name "FSF" is 4.
18168
18169 If the value of namesz is zero, there is no name present. */
18170
18171static bfd_boolean
18172process_note (Elf_Internal_Note * pnote,
18173 Filedata * filedata)
18174{
18175 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18176 const char * nt;
18177
18178 if (pnote->namesz == 0)
18179 /* If there is no note name, then use the default set of
18180 note type strings. */
18181 nt = get_note_type (filedata, pnote->type);
18182
18183 else if (const_strneq (pnote->namedata, "GNU"))
18184 /* GNU-specific object file notes. */
18185 nt = get_gnu_elf_note_type (pnote->type);
18186
18187 else if (const_strneq (pnote->namedata, "FreeBSD"))
18188 /* FreeBSD-specific core file notes. */
18189 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18190
18191 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18192 /* NetBSD-specific core file notes. */
18193 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18194
18195 else if (const_strneq (pnote->namedata, "NetBSD"))
18196 /* NetBSD-specific core file notes. */
18197 return process_netbsd_elf_note (pnote);
18198
18199 else if (strneq (pnote->namedata, "SPU/", 4))
18200 {
18201 /* SPU-specific core file notes. */
18202 nt = pnote->namedata + 4;
18203 name = "SPU";
18204 }
18205
18206 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18207 /* VMS/ia64-specific file notes. */
18208 nt = get_ia64_vms_note_type (pnote->type);
18209
18210 else if (const_strneq (pnote->namedata, "stapsdt"))
18211 nt = get_stapsdt_note_type (pnote->type);
18212
18213 else
18214 /* Don't recognize this note name; just use the default set of
18215 note type strings. */
18216 nt = get_note_type (filedata, pnote->type);
18217
18218 printf (" ");
18219
18220 if (((const_strneq (pnote->namedata, "GA")
18221 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18222 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18223 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18224 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18225 print_gnu_build_attribute_name (pnote);
18226 else
18227 print_symbol (-20, name);
18228
18229 if (do_wide)
18230 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18231 else
18232 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18233
18234 if (const_strneq (pnote->namedata, "IPF/VMS"))
18235 return print_ia64_vms_note (pnote);
18236 else if (const_strneq (pnote->namedata, "GNU"))
18237 return print_gnu_note (filedata, pnote);
18238 else if (const_strneq (pnote->namedata, "stapsdt"))
18239 return print_stapsdt_note (pnote);
18240 else if (const_strneq (pnote->namedata, "CORE"))
18241 return print_core_note (pnote);
18242 else if (((const_strneq (pnote->namedata, "GA")
18243 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18244 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18245 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18246 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18247 return print_gnu_build_attribute_description (pnote, filedata);
18248
18249 if (pnote->descsz)
18250 {
18251 unsigned long i;
18252
18253 printf (_(" description data: "));
18254 for (i = 0; i < pnote->descsz; i++)
18255 printf ("%02x ", pnote->descdata[i]);
18256 if (!do_wide)
18257 printf ("\n");
18258 }
18259
18260 if (do_wide)
18261 printf ("\n");
18262
18263 return TRUE;
18264}
18265
18266static bfd_boolean
18267process_notes_at (Filedata * filedata,
18268 Elf_Internal_Shdr * section,
18269 bfd_vma offset,
18270 bfd_vma length,
18271 bfd_vma align)
18272{
18273 Elf_External_Note * pnotes;
18274 Elf_External_Note * external;
18275 char * end;
18276 bfd_boolean res = TRUE;
18277
18278 if (length <= 0)
18279 return FALSE;
18280
18281 if (section)
18282 {
18283 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18284 if (pnotes)
18285 {
18286 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18287 return FALSE;
18288 }
18289 }
18290 else
18291 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18292 _("notes"));
18293
18294 if (pnotes == NULL)
18295 return FALSE;
18296
18297 external = pnotes;
18298
18299 if (section)
18300 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18301 else
18302 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18303 (unsigned long) offset, (unsigned long) length);
18304
18305 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18306 specifies that notes should be aligned to 4 bytes in 32-bit
18307 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18308 we also support 4 byte alignment in 64-bit objects. If section
18309 alignment is less than 4, we treate alignment as 4 bytes. */
18310 if (align < 4)
18311 align = 4;
18312 else if (align != 4 && align != 8)
18313 {
18314 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18315 (long) align);
18316 return FALSE;
18317 }
18318
18319 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18320
18321 end = (char *) pnotes + length;
18322 while ((char *) external < end)
18323 {
18324 Elf_Internal_Note inote;
18325 size_t min_notesz;
18326 char * next;
18327 char * temp = NULL;
18328 size_t data_remaining = end - (char *) external;
18329
18330 if (!is_ia64_vms (filedata))
18331 {
18332 /* PR binutils/15191
18333 Make sure that there is enough data to read. */
18334 min_notesz = offsetof (Elf_External_Note, name);
18335 if (data_remaining < min_notesz)
18336 {
18337 warn (ngettext ("Corrupt note: only %ld byte remains, "
18338 "not enough for a full note\n",
18339 "Corrupt note: only %ld bytes remain, "
18340 "not enough for a full note\n",
18341 data_remaining),
18342 (long) data_remaining);
18343 break;
18344 }
18345 data_remaining -= min_notesz;
18346
18347 inote.type = BYTE_GET (external->type);
18348 inote.namesz = BYTE_GET (external->namesz);
18349 inote.namedata = external->name;
18350 inote.descsz = BYTE_GET (external->descsz);
18351 inote.descdata = ((char *) external
18352 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18353 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18354 next = ((char *) external
18355 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18356 }
18357 else
18358 {
18359 Elf64_External_VMS_Note *vms_external;
18360
18361 /* PR binutils/15191
18362 Make sure that there is enough data to read. */
18363 min_notesz = offsetof (Elf64_External_VMS_Note, name);
18364 if (data_remaining < min_notesz)
18365 {
18366 warn (ngettext ("Corrupt note: only %ld byte remains, "
18367 "not enough for a full note\n",
18368 "Corrupt note: only %ld bytes remain, "
18369 "not enough for a full note\n",
18370 data_remaining),
18371 (long) data_remaining);
18372 break;
18373 }
18374 data_remaining -= min_notesz;
18375
18376 vms_external = (Elf64_External_VMS_Note *) external;
18377 inote.type = BYTE_GET (vms_external->type);
18378 inote.namesz = BYTE_GET (vms_external->namesz);
18379 inote.namedata = vms_external->name;
18380 inote.descsz = BYTE_GET (vms_external->descsz);
18381 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18382 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18383 next = inote.descdata + align_power (inote.descsz, 3);
18384 }
18385
18386 /* PR 17531: file: 3443835e. */
18387 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18388 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18389 || (size_t) (inote.descdata - inote.namedata) > data_remaining
18390 || (size_t) (next - inote.descdata) < inote.descsz
18391 || ((size_t) (next - inote.descdata)
18392 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18393 {
18394 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18395 (unsigned long) ((char *) external - (char *) pnotes));
18396 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18397 inote.type, inote.namesz, inote.descsz, (int) align);
18398 break;
18399 }
18400
18401 external = (Elf_External_Note *) next;
18402
18403 /* Verify that name is null terminated. It appears that at least
18404 one version of Linux (RedHat 6.0) generates corefiles that don't
18405 comply with the ELF spec by failing to include the null byte in
18406 namesz. */
18407 if (inote.namedata[inote.namesz - 1] != '\0')
18408 {
18409 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18410 {
18411 temp = (char *) malloc (inote.namesz + 1);
18412 if (temp == NULL)
18413 {
18414 error (_("Out of memory allocating space for inote name\n"));
18415 res = FALSE;
18416 break;
18417 }
18418
18419 memcpy (temp, inote.namedata, inote.namesz);
18420 inote.namedata = temp;
18421 }
18422 inote.namedata[inote.namesz] = 0;
18423 }
18424
18425 if (! process_note (& inote, filedata))
18426 res = FALSE;
18427
18428 if (temp != NULL)
18429 {
18430 free (temp);
18431 temp = NULL;
18432 }
18433 }
18434
18435 free (pnotes);
18436
18437 return res;
18438}
18439
18440static bfd_boolean
18441process_corefile_note_segments (Filedata * filedata)
18442{
18443 Elf_Internal_Phdr * segment;
18444 unsigned int i;
18445 bfd_boolean res = TRUE;
18446
18447 if (! get_program_headers (filedata))
18448 return TRUE;
18449
18450 for (i = 0, segment = filedata->program_headers;
18451 i < filedata->file_header.e_phnum;
18452 i++, segment++)
18453 {
18454 if (segment->p_type == PT_NOTE)
18455 if (! process_notes_at (filedata, NULL,
18456 (bfd_vma) segment->p_offset,
18457 (bfd_vma) segment->p_filesz,
18458 (bfd_vma) segment->p_align))
18459 res = FALSE;
18460 }
18461
18462 return res;
18463}
18464
18465static bfd_boolean
18466process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18467{
18468 Elf_External_Note * pnotes;
18469 Elf_External_Note * external;
18470 char * end;
18471 bfd_boolean res = TRUE;
18472
18473 if (length <= 0)
18474 return FALSE;
18475
18476 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18477 _("v850 notes"));
18478 if (pnotes == NULL)
18479 return FALSE;
18480
18481 external = pnotes;
18482 end = (char*) pnotes + length;
18483
18484 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18485 (unsigned long) offset, (unsigned long) length);
18486
18487 while ((char *) external + sizeof (Elf_External_Note) < end)
18488 {
18489 Elf_External_Note * next;
18490 Elf_Internal_Note inote;
18491
18492 inote.type = BYTE_GET (external->type);
18493 inote.namesz = BYTE_GET (external->namesz);
18494 inote.namedata = external->name;
18495 inote.descsz = BYTE_GET (external->descsz);
18496 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18497 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18498
18499 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18500 {
18501 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18502 inote.descdata = inote.namedata;
18503 inote.namesz = 0;
18504 }
18505
18506 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18507
18508 if ( ((char *) next > end)
18509 || ((char *) next < (char *) pnotes))
18510 {
18511 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18512 (unsigned long) ((char *) external - (char *) pnotes));
18513 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18514 inote.type, inote.namesz, inote.descsz);
18515 break;
18516 }
18517
18518 external = next;
18519
18520 /* Prevent out-of-bounds indexing. */
18521 if ( inote.namedata + inote.namesz > end
18522 || inote.namedata + inote.namesz < inote.namedata)
18523 {
18524 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18525 (unsigned long) ((char *) external - (char *) pnotes));
18526 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18527 inote.type, inote.namesz, inote.descsz);
18528 break;
18529 }
18530
18531 printf (" %s: ", get_v850_elf_note_type (inote.type));
18532
18533 if (! print_v850_note (& inote))
18534 {
18535 res = FALSE;
18536 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18537 inote.namesz, inote.descsz);
18538 }
18539 }
18540
18541 free (pnotes);
18542
18543 return res;
18544}
18545
18546static bfd_boolean
18547process_note_sections (Filedata * filedata)
18548{
18549 Elf_Internal_Shdr * section;
18550 unsigned long i;
18551 unsigned int n = 0;
18552 bfd_boolean res = TRUE;
18553
18554 for (i = 0, section = filedata->section_headers;
18555 i < filedata->file_header.e_shnum && section != NULL;
18556 i++, section++)
18557 {
18558 if (section->sh_type == SHT_NOTE)
18559 {
18560 if (! process_notes_at (filedata, section,
18561 (bfd_vma) section->sh_offset,
18562 (bfd_vma) section->sh_size,
18563 (bfd_vma) section->sh_addralign))
18564 res = FALSE;
18565 n++;
18566 }
18567
18568 if (( filedata->file_header.e_machine == EM_V800
18569 || filedata->file_header.e_machine == EM_V850
18570 || filedata->file_header.e_machine == EM_CYGNUS_V850)
18571 && section->sh_type == SHT_RENESAS_INFO)
18572 {
18573 if (! process_v850_notes (filedata,
18574 (bfd_vma) section->sh_offset,
18575 (bfd_vma) section->sh_size))
18576 res = FALSE;
18577 n++;
18578 }
18579 }
18580
18581 if (n == 0)
18582 /* Try processing NOTE segments instead. */
18583 return process_corefile_note_segments (filedata);
18584
18585 return res;
18586}
18587
18588static bfd_boolean
18589process_notes (Filedata * filedata)
18590{
18591 /* If we have not been asked to display the notes then do nothing. */
18592 if (! do_notes)
18593 return TRUE;
18594
18595 if (filedata->file_header.e_type != ET_CORE)
18596 return process_note_sections (filedata);
18597
18598 /* No program headers means no NOTE segment. */
18599 if (filedata->file_header.e_phnum > 0)
18600 return process_corefile_note_segments (filedata);
18601
18602 printf (_("No note segments present in the core file.\n"));
18603 return TRUE;
18604}
18605
18606static unsigned char *
18607display_public_gnu_attributes (unsigned char * start,
18608 const unsigned char * const end)
18609{
18610 printf (_(" Unknown GNU attribute: %s\n"), start);
18611
18612 start += strnlen ((char *) start, end - start);
18613 display_raw_attribute (start, end);
18614
18615 return (unsigned char *) end;
18616}
18617
18618static unsigned char *
18619display_generic_attribute (unsigned char * start,
18620 unsigned int tag,
18621 const unsigned char * const end)
18622{
18623 if (tag == 0)
18624 return (unsigned char *) end;
18625
18626 return display_tag_value (tag, start, end);
18627}
18628
18629static bfd_boolean
18630process_arch_specific (Filedata * filedata)
18631{
18632 if (! do_arch)
18633 return TRUE;
18634
18635 switch (filedata->file_header.e_machine)
18636 {
18637 case EM_ARC:
18638 case EM_ARC_COMPACT:
18639 case EM_ARC_COMPACT2:
18640 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18641 display_arc_attribute,
18642 display_generic_attribute);
18643 case EM_ARM:
18644 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18645 display_arm_attribute,
18646 display_generic_attribute);
18647
18648 case EM_MIPS:
18649 case EM_MIPS_RS3_LE:
18650 return process_mips_specific (filedata);
18651
18652 case EM_MSP430:
18653 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18654 display_msp430x_attribute,
18655 display_generic_attribute);
18656
18657 case EM_NDS32:
18658 return process_nds32_specific (filedata);
18659
18660 case EM_PPC:
18661 case EM_PPC64:
18662 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18663 display_power_gnu_attribute);
18664
18665 case EM_S390:
18666 case EM_S390_OLD:
18667 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18668 display_s390_gnu_attribute);
18669
18670 case EM_SPARC:
18671 case EM_SPARC32PLUS:
18672 case EM_SPARCV9:
18673 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18674 display_sparc_gnu_attribute);
18675
18676 case EM_TI_C6000:
18677 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18678 display_tic6x_attribute,
18679 display_generic_attribute);
18680
18681 default:
18682 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18683 display_public_gnu_attributes,
18684 display_generic_attribute);
18685 }
18686}
18687
18688static bfd_boolean
18689get_file_header (Filedata * filedata)
18690{
18691 /* Read in the identity array. */
18692 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18693 return FALSE;
18694
18695 /* Determine how to read the rest of the header. */
18696 switch (filedata->file_header.e_ident[EI_DATA])
18697 {
18698 default:
18699 case ELFDATANONE:
18700 case ELFDATA2LSB:
18701 byte_get = byte_get_little_endian;
18702 byte_put = byte_put_little_endian;
18703 break;
18704 case ELFDATA2MSB:
18705 byte_get = byte_get_big_endian;
18706 byte_put = byte_put_big_endian;
18707 break;
18708 }
18709
18710 /* For now we only support 32 bit and 64 bit ELF files. */
18711 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18712
18713 /* Read in the rest of the header. */
18714 if (is_32bit_elf)
18715 {
18716 Elf32_External_Ehdr ehdr32;
18717
18718 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18719 return FALSE;
18720
18721 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
18722 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
18723 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
18724 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
18725 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18726 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18727 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
18728 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18729 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18730 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18731 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18732 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18733 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18734 }
18735 else
18736 {
18737 Elf64_External_Ehdr ehdr64;
18738
18739 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18740 we will not be able to cope with the 64bit data found in
18741 64 ELF files. Detect this now and abort before we start
18742 overwriting things. */
18743 if (sizeof (bfd_vma) < 8)
18744 {
18745 error (_("This instance of readelf has been built without support for a\n\
1874664 bit data type and so it cannot read 64 bit ELF files.\n"));
18747 return FALSE;
18748 }
18749
18750 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18751 return FALSE;
18752
18753 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
18754 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
18755 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
18756 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
18757 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18758 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
18759 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
18760 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
18761 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18762 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
18763 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18764 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
18765 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
18766 }
18767
18768 if (filedata->file_header.e_shoff)
18769 {
18770 /* There may be some extensions in the first section header. Don't
18771 bomb if we can't read it. */
18772 if (is_32bit_elf)
18773 get_32bit_section_headers (filedata, TRUE);
18774 else
18775 get_64bit_section_headers (filedata, TRUE);
18776 }
18777
18778 return TRUE;
18779}
18780
18781static void
18782close_file (Filedata * filedata)
18783{
18784 if (filedata)
18785 {
18786 if (filedata->handle)
18787 fclose (filedata->handle);
18788 free (filedata);
18789 }
18790}
18791
18792void
18793close_debug_file (void * data)
18794{
18795 close_file ((Filedata *) data);
18796}
18797
18798static Filedata *
18799open_file (const char * pathname)
18800{
18801 struct stat statbuf;
18802 Filedata * filedata = NULL;
18803
18804 if (stat (pathname, & statbuf) < 0
18805 || ! S_ISREG (statbuf.st_mode))
18806 goto fail;
18807
18808 filedata = calloc (1, sizeof * filedata);
18809 if (filedata == NULL)
18810 goto fail;
18811
18812 filedata->handle = fopen (pathname, "rb");
18813 if (filedata->handle == NULL)
18814 goto fail;
18815
18816 filedata->file_size = (bfd_size_type) statbuf.st_size;
18817 filedata->file_name = pathname;
18818
18819 if (! get_file_header (filedata))
18820 goto fail;
18821
18822 if (filedata->file_header.e_shoff)
18823 {
18824 bfd_boolean res;
18825
18826 /* Read the section headers again, this time for real. */
18827 if (is_32bit_elf)
18828 res = get_32bit_section_headers (filedata, FALSE);
18829 else
18830 res = get_64bit_section_headers (filedata, FALSE);
18831
18832 if (!res)
18833 goto fail;
18834 }
18835
18836 return filedata;
18837
18838 fail:
18839 if (filedata)
18840 {
18841 if (filedata->handle)
18842 fclose (filedata->handle);
18843 free (filedata);
18844 }
18845 return NULL;
18846}
18847
18848void *
18849open_debug_file (const char * pathname)
18850{
18851 return open_file (pathname);
18852}
18853
18854/* Process one ELF object file according to the command line options.
18855 This file may actually be stored in an archive. The file is
18856 positioned at the start of the ELF object. Returns TRUE if no
18857 problems were encountered, FALSE otherwise. */
18858
18859static bfd_boolean
18860process_object (Filedata * filedata)
18861{
18862 Filedata * separates;
18863 unsigned int i;
18864 bfd_boolean res = TRUE;
18865
18866 if (! get_file_header (filedata))
18867 {
18868 error (_("%s: Failed to read file header\n"), filedata->file_name);
18869 return FALSE;
18870 }
18871
18872 /* Initialise per file variables. */
18873 for (i = ARRAY_SIZE (version_info); i--;)
18874 version_info[i] = 0;
18875
18876 for (i = ARRAY_SIZE (dynamic_info); i--;)
18877 dynamic_info[i] = 0;
18878 dynamic_info_DT_GNU_HASH = 0;
18879
18880 /* Process the file. */
18881 if (show_name)
18882 printf (_("\nFile: %s\n"), filedata->file_name);
18883
18884 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18885 Note we do this even if cmdline_dump_sects is empty because we
18886 must make sure that the dump_sets array is zeroed out before each
18887 object file is processed. */
18888 if (filedata->num_dump_sects > cmdline.num_dump_sects)
18889 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18890
18891 if (cmdline.num_dump_sects > 0)
18892 {
18893 if (filedata->num_dump_sects == 0)
18894 /* A sneaky way of allocating the dump_sects array. */
18895 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18896
18897 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18898 memcpy (filedata->dump_sects, cmdline.dump_sects,
18899 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18900 }
18901
18902 if (! process_file_header (filedata))
18903 return FALSE;
18904
18905 if (! process_section_headers (filedata))
18906 {
18907 /* Without loaded section headers we cannot process lots of things. */
18908 do_unwind = do_version = do_dump = do_arch = FALSE;
18909
18910 if (! do_using_dynamic)
18911 do_syms = do_dyn_syms = do_reloc = FALSE;
18912 }
18913
18914 if (! process_section_groups (filedata))
18915 /* Without loaded section groups we cannot process unwind. */
18916 do_unwind = FALSE;
18917
18918 if (process_program_headers (filedata))
18919 process_dynamic_section (filedata);
18920 else
18921 res = FALSE;
18922
18923 if (! process_relocs (filedata))
18924 res = FALSE;
18925
18926 if (! process_unwind (filedata))
18927 res = FALSE;
18928
18929 if (! process_symbol_table (filedata))
18930 res = FALSE;
18931
18932 if (! process_syminfo (filedata))
18933 res = FALSE;
18934
18935 if (! process_version_sections (filedata))
18936 res = FALSE;
18937
18938 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18939 separates = load_separate_debug_file (filedata, filedata->file_name);
18940 else
18941 separates = NULL;
18942
18943 if (! process_section_contents (filedata))
18944 res = FALSE;
18945
18946 if (separates)
18947 {
18948 if (! process_section_headers (separates))
18949 res = FALSE;
18950 else if (! process_section_contents (separates))
18951 res = FALSE;
18952 }
18953
18954 if (! process_notes (filedata))
18955 res = FALSE;
18956
18957 if (! process_gnu_liblist (filedata))
18958 res = FALSE;
18959
18960 if (! process_arch_specific (filedata))
18961 res = FALSE;
18962
18963 free (filedata->program_headers);
18964 filedata->program_headers = NULL;
18965
18966 free (filedata->section_headers);
18967 filedata->section_headers = NULL;
18968
18969 free (filedata->string_table);
18970 filedata->string_table = NULL;
18971 filedata->string_table_length = 0;
18972
18973 if (dynamic_strings)
18974 {
18975 free (dynamic_strings);
18976 dynamic_strings = NULL;
18977 dynamic_strings_length = 0;
18978 }
18979
18980 if (dynamic_symbols)
18981 {
18982 free (dynamic_symbols);
18983 dynamic_symbols = NULL;
18984 num_dynamic_syms = 0;
18985 }
18986
18987 if (dynamic_syminfo)
18988 {
18989 free (dynamic_syminfo);
18990 dynamic_syminfo = NULL;
18991 }
18992
18993 if (dynamic_section)
18994 {
18995 free (dynamic_section);
18996 dynamic_section = NULL;
18997 }
18998
18999 if (section_headers_groups)
19000 {
19001 free (section_headers_groups);
19002 section_headers_groups = NULL;
19003 }
19004
19005 if (section_groups)
19006 {
19007 struct group_list * g;
19008 struct group_list * next;
19009
19010 for (i = 0; i < group_count; i++)
19011 {
19012 for (g = section_groups [i].root; g != NULL; g = next)
19013 {
19014 next = g->next;
19015 free (g);
19016 }
19017 }
19018
19019 free (section_groups);
19020 section_groups = NULL;
19021 }
19022
19023 free_debug_memory ();
19024
19025 return res;
19026}
19027
19028/* Process an ELF archive.
19029 On entry the file is positioned just after the ARMAG string.
19030 Returns TRUE upon success, FALSE otherwise. */
19031
19032static bfd_boolean
19033process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19034{
19035 struct archive_info arch;
19036 struct archive_info nested_arch;
19037 size_t got;
19038 bfd_boolean ret = TRUE;
19039
19040 show_name = TRUE;
19041
19042 /* The ARCH structure is used to hold information about this archive. */
19043 arch.file_name = NULL;
19044 arch.file = NULL;
19045 arch.index_array = NULL;
19046 arch.sym_table = NULL;
19047 arch.longnames = NULL;
19048
19049 /* The NESTED_ARCH structure is used as a single-item cache of information
19050 about a nested archive (when members of a thin archive reside within
19051 another regular archive file). */
19052 nested_arch.file_name = NULL;
19053 nested_arch.file = NULL;
19054 nested_arch.index_array = NULL;
19055 nested_arch.sym_table = NULL;
19056 nested_arch.longnames = NULL;
19057
19058 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19059 is_thin_archive, do_archive_index) != 0)
19060 {
19061 ret = FALSE;
19062 goto out;
19063 }
19064
19065 if (do_archive_index)
19066 {
19067 if (arch.sym_table == NULL)
19068 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19069 else
19070 {
19071 unsigned long i, l;
19072 unsigned long current_pos;
19073
19074 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19075 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19076
19077 current_pos = ftell (filedata->handle);
19078
19079 for (i = l = 0; i < arch.index_num; i++)
19080 {
19081 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19082 {
19083 char * member_name;
19084
19085 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19086
19087 if (member_name != NULL)
19088 {
19089 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19090
19091 if (qualified_name != NULL)
19092 {
19093 printf (_("Contents of binary %s at offset "), qualified_name);
19094 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19095 putchar ('\n');
19096 free (qualified_name);
19097 }
19098 }
19099 }
19100
19101 if (l >= arch.sym_size)
19102 {
19103 error (_("%s: end of the symbol table reached before the end of the index\n"),
19104 filedata->file_name);
19105 ret = FALSE;
19106 break;
19107 }
19108 /* PR 17531: file: 0b6630b2. */
19109 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19110 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19111 }
19112
19113 if (arch.uses_64bit_indices)
19114 l = (l + 7) & ~ 7;
19115 else
19116 l += l & 1;
19117
19118 if (l < arch.sym_size)
19119 {
19120 error (ngettext ("%s: %ld byte remains in the symbol table, "
19121 "but without corresponding entries in "
19122 "the index table\n",
19123 "%s: %ld bytes remain in the symbol table, "
19124 "but without corresponding entries in "
19125 "the index table\n",
19126 arch.sym_size - l),
19127 filedata->file_name, arch.sym_size - l);
19128 ret = FALSE;
19129 }
19130
19131 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19132 {
19133 error (_("%s: failed to seek back to start of object files in the archive\n"),
19134 filedata->file_name);
19135 ret = FALSE;
19136 goto out;
19137 }
19138 }
19139
19140 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19141 && !do_segments && !do_header && !do_dump && !do_version
19142 && !do_histogram && !do_debugging && !do_arch && !do_notes
19143 && !do_section_groups && !do_dyn_syms)
19144 {
19145 ret = TRUE; /* Archive index only. */
19146 goto out;
19147 }
19148 }
19149
19150 while (1)
19151 {
19152 char * name;
19153 size_t namelen;
19154 char * qualified_name;
19155
19156 /* Read the next archive header. */
19157 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19158 {
19159 error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19160 return FALSE;
19161 }
19162 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19163 if (got != sizeof arch.arhdr)
19164 {
19165 if (got == 0)
19166 break;
19167 error (_("%s: failed to read archive header\n"), filedata->file_name);
19168 ret = FALSE;
19169 break;
19170 }
19171 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19172 {
19173 error (_("%s: did not find a valid archive header\n"), arch.file_name);
19174 ret = FALSE;
19175 break;
19176 }
19177
19178 arch.next_arhdr_offset += sizeof arch.arhdr;
19179
19180 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19181 if (archive_file_size & 01)
19182 ++archive_file_size;
19183
19184 name = get_archive_member_name (&arch, &nested_arch);
19185 if (name == NULL)
19186 {
19187 error (_("%s: bad archive file name\n"), filedata->file_name);
19188 ret = FALSE;
19189 break;
19190 }
19191 namelen = strlen (name);
19192
19193 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19194 if (qualified_name == NULL)
19195 {
19196 error (_("%s: bad archive file name\n"), filedata->file_name);
19197 ret = FALSE;
19198 break;
19199 }
19200
19201 if (is_thin_archive && arch.nested_member_origin == 0)
19202 {
19203 /* This is a proxy for an external member of a thin archive. */
19204 Filedata * member_filedata;
19205 char * member_file_name = adjust_relative_path
19206 (filedata->file_name, name, namelen);
19207
19208 if (member_file_name == NULL)
19209 {
19210 ret = FALSE;
19211 break;
19212 }
19213
19214 member_filedata = open_file (member_file_name);
19215 if (member_filedata == NULL)
19216 {
19217 error (_("Input file '%s' is not readable.\n"), member_file_name);
19218 free (member_file_name);
19219 ret = FALSE;
19220 break;
19221 }
19222
19223 archive_file_offset = arch.nested_member_origin;
19224 member_filedata->file_name = qualified_name;
19225
19226 if (! process_object (member_filedata))
19227 ret = FALSE;
19228
19229 close_file (member_filedata);
19230 free (member_file_name);
19231 }
19232 else if (is_thin_archive)
19233 {
19234 Filedata thin_filedata;
19235
19236 memset (&thin_filedata, 0, sizeof (thin_filedata));
19237
19238 /* PR 15140: Allow for corrupt thin archives. */
19239 if (nested_arch.file == NULL)
19240 {
19241 error (_("%s: contains corrupt thin archive: %s\n"),
19242 filedata->file_name, name);
19243 ret = FALSE;
19244 break;
19245 }
19246
19247 /* This is a proxy for a member of a nested archive. */
19248 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19249
19250 /* The nested archive file will have been opened and setup by
19251 get_archive_member_name. */
19252 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19253 {
19254 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19255 ret = FALSE;
19256 break;
19257 }
19258
19259 thin_filedata.handle = nested_arch.file;
19260 thin_filedata.file_name = qualified_name;
19261
19262 if (! process_object (& thin_filedata))
19263 ret = FALSE;
19264 }
19265 else
19266 {
19267 archive_file_offset = arch.next_arhdr_offset;
19268 arch.next_arhdr_offset += archive_file_size;
19269
19270 filedata->file_name = qualified_name;
19271 if (! process_object (filedata))
19272 ret = FALSE;
19273 }
19274
19275 if (filedata->dump_sects != NULL)
19276 {
19277 free (filedata->dump_sects);
19278 filedata->dump_sects = NULL;
19279 filedata->num_dump_sects = 0;
19280 }
19281
19282 free (qualified_name);
19283 }
19284
19285 out:
19286 if (nested_arch.file != NULL)
19287 fclose (nested_arch.file);
19288 release_archive (&nested_arch);
19289 release_archive (&arch);
19290
19291 return ret;
19292}
19293
19294static bfd_boolean
19295process_file (char * file_name)
19296{
19297 Filedata * filedata = NULL;
19298 struct stat statbuf;
19299 char armag[SARMAG];
19300 bfd_boolean ret = TRUE;
19301
19302 if (stat (file_name, &statbuf) < 0)
19303 {
19304 if (errno == ENOENT)
19305 error (_("'%s': No such file\n"), file_name);
19306 else
19307 error (_("Could not locate '%s'. System error message: %s\n"),
19308 file_name, strerror (errno));
19309 return FALSE;
19310 }
19311
19312 if (! S_ISREG (statbuf.st_mode))
19313 {
19314 error (_("'%s' is not an ordinary file\n"), file_name);
19315 return FALSE;
19316 }
19317
19318 filedata = calloc (1, sizeof * filedata);
19319 if (filedata == NULL)
19320 {
19321 error (_("Out of memory allocating file data structure\n"));
19322 return FALSE;
19323 }
19324
19325 filedata->file_name = file_name;
19326 filedata->handle = fopen (file_name, "rb");
19327 if (filedata->handle == NULL)
19328 {
19329 error (_("Input file '%s' is not readable.\n"), file_name);
19330 free (filedata);
19331 return FALSE;
19332 }
19333
19334 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19335 {
19336 error (_("%s: Failed to read file's magic number\n"), file_name);
19337 fclose (filedata->handle);
19338 free (filedata);
19339 return FALSE;
19340 }
19341
19342 filedata->file_size = (bfd_size_type) statbuf.st_size;
19343
19344 if (memcmp (armag, ARMAG, SARMAG) == 0)
19345 {
19346 if (! process_archive (filedata, FALSE))
19347 ret = FALSE;
19348 }
19349 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19350 {
19351 if ( ! process_archive (filedata, TRUE))
19352 ret = FALSE;
19353 }
19354 else
19355 {
19356 if (do_archive_index)
19357 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19358 file_name);
19359
19360 rewind (filedata->handle);
19361 archive_file_size = archive_file_offset = 0;
19362
19363 if (! process_object (filedata))
19364 ret = FALSE;
19365 }
19366
19367 fclose (filedata->handle);
19368 free (filedata);
19369
19370 return ret;
19371}
19372
19373#ifdef SUPPORT_DISASSEMBLY
19374/* Needed by the i386 disassembler. For extra credit, someone could
19375 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19376 symbols. */
19377
19378void
19379print_address (unsigned int addr, FILE * outfile)
19380{
19381 fprintf (outfile,"0x%8.8x", addr);
19382}
19383
19384/* Needed by the i386 disassembler. */
19385
19386void
19387db_task_printsym (unsigned int addr)
19388{
19389 print_address (addr, stderr);
19390}
19391#endif
19392
19393int
19394main (int argc, char ** argv)
19395{
19396 int err;
19397
19398#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19399 setlocale (LC_MESSAGES, "");
19400#endif
19401#if defined (HAVE_SETLOCALE)
19402 setlocale (LC_CTYPE, "");
19403#endif
19404 bindtextdomain (PACKAGE, LOCALEDIR);
19405 textdomain (PACKAGE);
19406
19407 expandargv (&argc, &argv);
19408
19409 cmdline.file_name = "<cmdline>";
19410 parse_args (& cmdline, argc, argv);
19411
19412 if (optind < (argc - 1))
19413 show_name = TRUE;
19414 else if (optind >= argc)
19415 {
19416 warn (_("Nothing to do.\n"));
19417 usage (stderr);
19418 }
19419
19420 err = FALSE;
19421 while (optind < argc)
19422 if (! process_file (argv[optind++]))
19423 err = TRUE;
19424
19425 if (cmdline.dump_sects != NULL)
19426 free (cmdline.dump_sects);
19427
19428 return err ? EXIT_FAILURE : EXIT_SUCCESS;
19429}
A mirror of the official binutils-gdb repository